hclang 0.15.1 → 0.16.0

package/esm/cli/hc.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import "../_dnt.polyfills.js";
 import * as dntShim from "../_dnt.shims.js";
+import { visibleEnvironment } from "../lib/execute/env-visibility.js";
 import { HCEval, make_context } from "../lib/execute/hc-eval.js";
 import { HCLog } from "../lib/execute/hc-log.js";
 import { HCTest } from "../lib/execute/hc-test.js";
@@ -8,7 +9,7 @@ import { parseArgs } from "../deps/jsr.io/@std/cli/1.0.32/parse_args.js";
 import { runfile } from "./runfile.js";
 import { Prompt } from "./prompt.js";
 import { DenoFileStore } from "./resource-store.js";
-import { Frame, FrameResource, RESOURCE_ROOT_KEY, } from "../lib/frames.js";
+import { CLOCK_SCHEME, ClockHandler, Frame, FrameResource, RealClock, RESOURCE_ROOT_KEY, ResourceHandlers, } from "../lib/frames.js";
 /**
  * @module hc
  *
@@ -71,9 +72,26 @@ export function getHost(context = {}) {
     // logger holds the same one: the root binding belongs to the host namespace
     // and nowhere else.
     const host = new Frame({ ...context });
-    host.set(RESOURCE_ROOT_KEY, FrameResource.root(new DenoFileStore()));
+    host.set(RESOURCE_ROOT_KEY, FrameResource.root(new DenoFileStore(), getHandlers()));
     return host;
 }
+/**
+ * This harness's scheme table.
+ *
+ * One entry, and the emptiness of every other slot is the point: `'https://…'`
+ * refuses because nothing is bound to `https`, not because a rule forbids it.
+ * The CLI installs the real clock, which is the only thing this harness can
+ * honestly implement that the root binding does not already cover.
+ *
+ * Exported so a test can run under the table the CLI actually grants.
+ *
+ * @returns The scheme handlers reachable from a CLI evaluation.
+ */
+export function getHandlers() {
+    return ResourceHandlers.of({
+        [CLOCK_SCHEME]: new ClockHandler(new RealClock()),
+    });
+}
 /**
  * The main function for the CLI application.
  *
@@ -147,7 +165,10 @@ export async function main(hcEval, options) {
     return lexicalComplete ? test?.exitCode ?? 0 : 1;
 }
 if (globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).main) {
-    const env = dntShim.Deno.env.toObject();
+    // One name at a time, through the dictionary. A wholesale read would hand the
+    // whole process environment to `$$` again, and the flags this harness runs
+    // under are a derived artifact rather than the bound.
+    const env = visibleEnvironment((name) => dntShim.Deno.env.get(name));
     const options = getOptions(dntShim.Deno.args);
     const hc_eval = getEval(env);
     main(hc_eval, options).then((exitCode) => {

package/esm/lib/execute/env-visibility.js

@@ -0,0 +1,80 @@
+/**
+ * Standard UNIX variables, which describe the invocation rather than the host's
+ * secrets. Every one of these is already visible to anything the user runs.
+ */
+const UNIX_VARIABLES = [
+    "HOME",
+    "HOSTNAME",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "LOGNAME",
+    "PATH",
+    "PWD",
+    "SHELL",
+    "SHLVL",
+    "TMPDIR",
+    "TZ",
+    "USER",
+];
+/**
+ * Variables open-source tooling probes.
+ *
+ * This group is load-bearing rather than generous: the CLI's own dependency
+ * tree reads the colour-support family, and `DEBUG`/`DEBUG_ENV` are read by the
+ * logger and the context builder. Omitting them would leave a dictionary that
+ * looks tidy and breaks the harness that uses it.
+ *
+ * Deliberately absent: the CI-vendor names that same dependency reads to guess
+ * at colour support — `TF_BUILD`, `GITHUB_ACTIONS`, `TRAVIS`, and a dozen more.
+ * Which CI a build runs under is the harness's business, not a property of the
+ * invocation a program should describe itself with, and they reach the dependency
+ * through the flag rather than through this dictionary. The vendor-neutral `CI`
+ * stays, because that one is a fact about the invocation.
+ */
+const TOOLING_VARIABLES = [
+    "CI",
+    "COLORTERM",
+    "DEBUG",
+    "DEBUG_ENV",
+    "EDITOR",
+    "FORCE_COLOR",
+    "NO_COLOR",
+    "PAGER",
+    "TERM",
+    "TERM_PROGRAM",
+    "TERM_PROGRAM_VERSION",
+];
+/** The curated default dictionary, which a harness may replace wholesale. */
+export const VISIBLE_ENVIRONMENT = Object.freeze([
+    ...UNIX_VARIABLES,
+    ...TOOLING_VARIABLES,
+]);
+/**
+ * Reads only the declared variables, one name at a time.
+ *
+ * Never a wholesale read. Asking for the names the dictionary lists is what
+ * makes the dictionary the bound: a variable it omits is never read, so it
+ * cannot arrive by accident when the host grows a new one.
+ *
+ * A read the host refuses is absent for the same reason a read the dictionary
+ * omits is absent — the harness's own permission flags must not become
+ * something a program can detect.
+ */
+export const visibleEnvironment = (read, visible = VISIBLE_ENVIRONMENT) => {
+    const environment = {};
+    for (const name of visible) {
+        const value = readOrAbsent(read, name);
+        if (value !== undefined)
+            environment[name] = value;
+    }
+    return environment;
+};
+const readOrAbsent = (read, name) => {
+    try {
+        return read(name);
+    }
+    catch {
+        return undefined;
+    }
+};

package/esm/lib/execute/syntax.js

@@ -32,6 +32,7 @@ export const syntaxFacets = [
     frame.FrameString.SYNTAX,
     frame.FrameStringEnd.SYNTAX,
     frame.FrameSymbol.SYNTAX,
+    frame.FrameTime.SYNTAX,
     frame.FrameURI.SYNTAX,
 ];
 const lexicalModes = {

package/esm/lib/frames/atom-syntax.js

@@ -9,6 +9,15 @@
  * @module
  */
 import { ScanDisposition } from "../scan.js";
+/**
+ * The delimiter that opens and closes a time literal.
+ *
+ * The time family owns it, but the operator family has to agree about it: `%` is
+ * an operator continuation character, so without a shared name an operator would
+ * swallow the sigil of a literal abutting it. It lives here, with the other
+ * facts both families read, rather than in either one of them.
+ */
+export const TIME_DELIMITER = "%";
 /** Counts non-overlapping occurrences of `token` in `source`. */
 const occurrences = (source, token) => source.split(token).length - 1;
 /** Consume an accepted character; otherwise end the atom before it. */

package/esm/lib/frames/clock.js

@@ -0,0 +1,177 @@
+/**
+ * The clock, as a handler table entry.
+ *
+ * A time literal is inert data; reading the current instant is not. `now` reads
+ * something outside the program, so it cannot be ambient — there is no nameable
+ * primitive for it and therefore no way for a program to request one. The clock
+ * is a harness grant like any other resource, spelled `'clock:now'`, and a
+ * harness that installs no clock leaves the scheme an empty slot.
+ *
+ * Real, frozen, and scripted clocks are three entries, not three modes. The
+ * program is byte-identical across all of them, exactly as it is across any other
+ * handler swap, which is what finally lets a `;` source and `#` expected pair say
+ * something time-dependent.
+ *
+ * What holds for a program that is refused: no reading is available, whether the
+ * scheme was never bound or the clock declined, and either way the refusal is an
+ * ordinary value that flows back through evaluation rather than raising. It does
+ * *not* hold that the two are indistinguishable — `$!.resource-scheme-unbound`
+ * and `$!.clock-exhausted` are different values, and a program can read them.
+ * That is deliberate here and general to the resource primitive, whose refusals
+ * are nameable by design; `spec/a12-resource-frames.md` records the tension with
+ * a07 §7's stronger claim rather than resolving it in this one handler.
+ *
+ * @module
+ */
+import { FrameDateTime } from "./frame-time.js";
+/** The scheme a harness binds a clock to. */
+export const CLOCK_SCHEME = "clock";
+/** The one reading a clock answers to. */
+const NOW = "now";
+/** The host clock, which prod installs and nothing else should. */
+export class RealClock {
+    describe() {
+        return "real";
+    }
+    now() {
+        return { ok: true, instant: FrameDateTime.fromEpochMillis(Date.now()) };
+    }
+}
+/**
+ * One instant, answered every time.
+ *
+ * This is what retires the deterministic-build-timestamp workaround: a
+ * reproducible build pins the clock instead of deriving a substitute for one.
+ */
+export class FrozenClock {
+    constructor(instant) {
+        Object.defineProperty(this, "instant", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: instant
+        });
+    }
+    describe() {
+        return `frozen ${this.instant.canonical()}`;
+    }
+    now() {
+        return { ok: true, instant: this.instant };
+    }
+}
+/**
+ * A finite script of instants, which refuses once spent.
+ *
+ * Exhaustion is the clock refusing, which is the general shape a time budget
+ * takes: a limit on time is a duration plus a clock, not a limiter subsystem.
+ */
+export class ScriptedClock {
+    constructor(readings) {
+        Object.defineProperty(this, "readings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: readings
+        });
+        Object.defineProperty(this, "next", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    describe() {
+        return `scripted ${this.readings.length}`;
+    }
+    now() {
+        const reading = this.readings[this.next];
+        if (reading === undefined) {
+            return { ok: false, reason: "clock-exhausted" };
+        }
+        this.next += 1;
+        return { ok: true, instant: reading };
+    }
+}
+/**
+ * A clock that stops once a duration has elapsed.
+ *
+ * The budget is a duration value and the exhaustion is the clock refusing, so
+ * nothing here is a scheduler: the first reading starts the budget and a reading
+ * past it is `clock-budget-spent`.
+ */
+export class BudgetClock {
+    constructor(clock, budget) {
+        Object.defineProperty(this, "clock", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: clock
+        });
+        Object.defineProperty(this, "budget", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: budget
+        });
+        Object.defineProperty(this, "started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    describe() {
+        return `budget ${this.budget.canonical()} on ${this.clock.describe()}`;
+    }
+    now() {
+        const reading = this.clock.now();
+        if (!reading.ok)
+            return reading;
+        this.started ??= reading.instant.nanos;
+        return reading.instant.nanos - this.started > this.budget.nanos
+            ? { ok: false, reason: "clock-budget-spent" }
+            : reading;
+    }
+}
+/**
+ * Binds a clock to the `clock` scheme.
+ *
+ * Reading answers the instant itself rather than its characters, because the
+ * handler already knows the value and spelling it as text would only make every
+ * reader parse it back. Writing is refused: a clock is an observation, and a
+ * program that could set one could make its own history.
+ */
+export class ClockHandler {
+    constructor(clock) {
+        Object.defineProperty(this, "clock", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: clock
+        });
+    }
+    describe() {
+        return `${CLOCK_SCHEME}:${this.clock.describe()}`;
+    }
+    read(reference) {
+        if (!ClockHandler.readsNow(reference)) {
+            return { ok: false, reason: "clock-unreadable" };
+        }
+        const reading = this.clock.now();
+        return reading.ok
+            ? { ok: true, elements: [reading.instant] }
+            : { ok: false, reason: reading.reason };
+    }
+    write(_reference, _content) {
+        return { ok: false, reason: "clock-read-only" };
+    }
+    /** `'clock:now'` is the whole vocabulary; anything else names nothing. */
+    static readsNow(reference) {
+        if (reference.authority !== undefined)
+            return false;
+        if (reference.query !== undefined || reference.fragment !== undefined) {
+            return false;
+        }
+        return (reference.path ?? "").replace(/^\/+/, "") === NOW;
+    }
+}

package/esm/lib/frames/dimensional-algebra.js

@@ -0,0 +1,43 @@
+/**
+ * Which operand kinds combine, and what they answer.
+ *
+ * Datetime and duration are a two-element instance of the general dimensional
+ * rule, not a special case of time: an instant is a point on a line, a duration
+ * is an interval on it, and the algebra that relates them is the affine one.
+ * Writing it as a table rather than as branches inside a frame class is what
+ * keeps the units work from becoming a parallel implementation of the same
+ * rules — a dimensioned quantity is an interval on its own line, and a plain
+ * number is the scalar.
+ *
+ * The table is the whole ruling. A combination it does not name has no meaning,
+ * so the caller answers a type error rather than inventing one, which is how
+ * `datetime + datetime` becomes an error frame instead of a second datetime.
+ *
+ * @module
+ */
+/**
+ * Every combination that means something, keyed by operator and operand kinds.
+ *
+ * Read the omissions as deliberately as the entries: `+ point point` has no
+ * meaning because adding two positions depends on an origin the values do not
+ * carry, and `- interval point` is refused because subtraction is not
+ * commutative and a displacement minus a position is not a position.
+ */
+const RESULTS = Object.freeze({
+    "+ point interval": "point",
+    "+ interval point": "point",
+    "+ interval interval": "interval",
+    "+ scalar scalar": "scalar",
+    "- point point": "interval",
+    "- point interval": "point",
+    "- interval interval": "interval",
+    "- scalar scalar": "scalar",
+    "* interval scalar": "interval",
+    "* scalar interval": "interval",
+    "* scalar scalar": "scalar",
+    "/ interval scalar": "interval",
+    "/ interval interval": "scalar",
+    "/ scalar scalar": "scalar",
+});
+/** The kind this combination answers, or undefined when it has no meaning. */
+export const dimensionalResult = (operator, left, right) => RESULTS[`${operator} ${left} ${right}`];

package/esm/lib/frames/frame-numeric.js

@@ -78,7 +78,7 @@ export class FrameNumeric extends FrameAtom {
     }
     divide(right) {
         if (this.rank == null || right.rank == null) {
-            return this.operationError("/", right);
+            return this.reflect("/", right) ?? this.operationError("/", right);
         }
         if (right.isZero())
             return Frame.error("$!.division-by-zero /");
@@ -171,6 +171,17 @@ export class FrameNumeric extends FrameAtom {
     exactInt(_max) {
         return Frame.error(`$!.exact-integer-required ${this.className()}`);
     }
+    /**
+     * The exact ratio this frame denotes, or null when it denotes none.
+     *
+     * Published so a null-ranked peer outside the promotion ladder can scale by an
+     * exact scalar without joining the ladder to do it. An inexact value answers
+     * null, which is what keeps such a peer's arithmetic exact by construction
+     * rather than by rounding.
+     */
+    exactRatio() {
+        return this.ratioParts();
+    }
     operationError(operator, right) {
         return Frame.error(`$!.numeric-domain ${operator} ${this.className()} ${right.className()}`);
     }
@@ -180,6 +191,17 @@ export class FrameNumeric extends FrameAtom {
     repeat(_argument, _parameter) {
         return this.repetitionError();
     }
+    /**
+     * A right operand's chance to define an operation its left cannot.
+     *
+     * A value outside the promotion ladder carries rules the ladder does not know:
+     * a duration times a number is a duration, whichever side the number was
+     * written on. Answering `undefined` — which every ranked type does — leaves the
+     * domain error exactly as it was, so this adds a case rather than changing one.
+     */
+    combineFrom(_operator, _left) {
+        return undefined;
+    }
     /**
      * A numeric `up` link is the receiver a property lookup climbed from, not a
      * lexical scope, so it must not answer a later segment. Without this, an
@@ -201,11 +223,18 @@ export class FrameNumeric extends FrameAtom {
     }
     join(right, operator, operation) {
         if (this.rank == null || right.rank == null) {
-            return this.operationError(operator, right);
+            return this.reflect(operator, right) ??
+                this.operationError(operator, right);
         }
         const target = Math.max(this.rank, right.rank);
         return operation(this.promoteTo(target), right.promoteTo(target));
     }
+    /** Offers an unranked right operand the operation, once, before refusing. */
+    reflect(operator, right) {
+        return this.rank != null && right.rank == null
+            ? right.combineFrom(operator, this)
+            : undefined;
+    }
     order(right, operator, predicate) {
         if (this.rank == null || right.rank == null) {
             return this.operationError(operator, right);

package/esm/lib/frames/frame-resource.js

@@ -12,8 +12,12 @@
  * promises about a resource identifier still has to hold. A resource prints as
  * the reference it was written as, compares by that reference, and publishes the
  * same RFC 3986 components. What it adds is the authority, and the authority is
- * private: the store is a TypeScript field, never metadata, so it is not
- * reachable by property enumeration.
+ * private: the store and the handler table are TypeScript fields, never
+ * metadata, so neither is reachable by property enumeration.
+ *
+ * Two planes, selected by whether the reference publishes a scheme. The path
+ * plane extends the root binding and is bounded by normalization. The scheme
+ * plane dispatches to a handler table entry, where an empty slot is the refusal.
  *
  * @module
  */
@@ -22,7 +26,8 @@ import { FrameInt } from "./frame-int.js";
 import { FrameString } from "./frame-string.js";
 import { FrameURI } from "./frame-uri.js";
 import { hasCharacterContent } from "./frame-text.js";
-import { joinNormalized, normalizeReference, } from "./resource-reference.js";
+import { ResourceHandlers } from "./resource-handlers.js";
+import { decomposeReference, joinNormalized, normalizeReference, } from "./resource-reference.js";
 /** The reference a root binding prints and normalizes as itself. */
 const ROOT_REFERENCE = ".";
 export class FrameResource extends FrameURI {
@@ -32,16 +37,23 @@ export class FrameResource extends FrameURI {
      * The root is a resource at the empty path, which is what makes extension the
      * only operation and attenuation structural rather than checked: a child is a
      * longer path on the same store, and no path is shorter than the empty one.
+     *
+     * The handler table defaults to empty, so a harness that installs nothing
+     * grants nothing: every scheme is an empty slot until one is bound.
      */
-    static root(store) {
-        return new FrameResource(ROOT_REFERENCE, store, { ok: true, path: "" });
+    static root(store, handlers = ResourceHandlers.none) {
+        return new FrameResource(ROOT_REFERENCE, store, handlers, {
+            kind: "path",
+            path: "",
+        });
     }
     /**
      * @param reference The reference as written, which stays the printed form.
-     * @param store The host seam this resource and its children share.
-     * @param location The normalization decided before this frame existed.
+     * @param store The host seam this resource and its path children share.
+     * @param handlers The scheme table this resource dispatches through.
+     * @param placement The plane and location decided before this frame existed.
      */
-    constructor(reference, store, location) {
+    constructor(reference, store, handlers, placement) {
         super(reference);
         Object.defineProperty(this, "store", {
             enumerable: true,
@@ -49,23 +61,29 @@ export class FrameResource extends FrameURI {
             writable: true,
             value: store
         });
-        Object.defineProperty(this, "location", {
+        Object.defineProperty(this, "handlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: handlers
+        });
+        Object.defineProperty(this, "placement", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: location
+            value: placement
         });
     }
     /**
      * Extends this binding by one reference.
      *
-     * Normalization runs here, before any dispatch could select a handler, and it
-     * is pure: a refused reference still yields a resource, carrying its refusal.
-     * Surfacing the refusal at construction instead would make evaluating
+     * Normalization runs here, before dispatch selects a handler, and it is pure:
+     * a refused reference still yields a resource, carrying its refusal. Surfacing
+     * the refusal at construction instead would make evaluating
      * `'https://example.com/x'` an error, and a03 requires evaluation to be inert.
      */
     extend(reference) {
-        return new FrameResource(reference, this.store, this.locate(reference));
+        return new FrameResource(reference, this.store, this.handlers, this.locate(reference));
     }
     /** A resource is a value, and evaluating one performs no access. */
     in() {
@@ -79,33 +97,46 @@ export class FrameResource extends FrameURI {
      * masquerade as it.
      */
     apply(argument, _parameter = Frame.nil) {
-        const path = this.contained();
-        if (path === undefined)
-            return this.refusal();
+        const placement = this.placement;
+        if (placement.kind === "refused") {
+            return this.storeRefusal(placement.reason);
+        }
         const content = hasCharacterContent(argument)
             ? argument.characterContent()
             : argument.toString();
-        const written = this.store.write(path, content);
+        if (placement.kind === "scheme") {
+            const written = placement.handler.write(placement.parts, content);
+            return written.ok
+                ? FrameInt.for(written.count.toString())
+                : this.storeRefusal(written.reason);
+        }
+        const written = this.store.write(placement.path, content);
         return written.ok
             ? FrameInt.for(written.content.length.toString())
             : this.storeRefusal(written.reason);
     }
     /**
-     * Reading pushes characters, because the character is the primitive.
+     * Reading pushes elements, and for a store the element is the character.
      *
      * No part of the reading is a property of the source: a receiver accepts the
      * characters and decides whether they are whole content, a list, chunks, or HC
-     * code. That is why nothing here declares an element type, and why choosing
-     * lines would have decided downstream composition by accident.
+     * code. A scheme handler answers its own elements instead, because a handler
+     * is not required to be a byte store — a clock knows the instant it read, and
+     * spelling it as characters would only make the reader parse it back.
      *
      * A refusal arrives as the single element, so it flows back through the
      * reduce as an ordinary value rather than raising.
      */
     elements() {
-        const path = this.contained();
-        if (path === undefined)
-            return [this.refusal()];
-        const read = this.store.read(path);
+        const placement = this.placement;
+        if (placement.kind === "refused") {
+            return [this.storeRefusal(placement.reason)];
+        }
+        if (placement.kind === "scheme") {
+            const read = placement.handler.read(placement.parts);
+            return read.ok ? [...read.elements] : [this.storeRefusal(read.reason)];
+        }
+        const read = this.store.read(placement.path);
         if (!read.ok)
             return [this.storeRefusal(read.reason)];
         return [...read.content].map((char) => new FrameString(char));
@@ -125,28 +156,55 @@ export class FrameResource extends FrameURI {
     describeRoot() {
         return this.store.describe();
     }
+    /**
+     * The schemes this binding can reach, for a harness or a test.
+     *
+     * Not reachable from HC. The adapter surface is enumerable so a harness can
+     * audit it, and a program that could enumerate it could probe its host.
+     */
+    boundSchemes() {
+        return this.handlers.schemes();
+    }
     /**
      * Locates a child, keeping a refused parent refused.
      *
      * A refusal is inherited before the child's own reference is even consulted,
      * because attenuation has no meaning below a location that was never reached.
      * Extending a refusal must not launder it into an allowed path.
+     *
+     * A handler's resource is a leaf: what lies below `'https://host/a'` is the
+     * handler's business, not a path this binding may compose, so extending one is
+     * refused rather than guessed at.
      */
     locate(reference) {
-        if (!this.location.ok)
-            return this.location;
+        if (this.placement.kind === "refused")
+            return this.placement;
+        if (this.placement.kind === "scheme") {
+            return { kind: "refused", reason: "resource-not-extensible" };
+        }
+        const parts = decomposeReference(reference);
+        if (parts.scheme !== undefined)
+            return this.dispatch(parts);
         const normal = normalizeReference(reference);
         if (!normal.ok)
-            return normal;
-        return { ok: true, path: joinNormalized(this.location.path, normal.path) };
+            return { kind: "refused", reason: normal.reason };
+        return {
+            kind: "path",
+            path: joinNormalized(this.placement.path, normal.path),
+        };
     }
-    /** The normalized path, or undefined when normalization refused. */
-    contained() {
-        return this.location.ok ? this.location.path : undefined;
-    }
-    refusal() {
-        const reason = this.location.ok ? "resource-refused" : this.location.reason;
-        return this.storeRefusal(reason);
+    /**
+     * Selects the handler a scheme names, or refuses without a host call.
+     *
+     * The empty slot is the refusal. Nothing here consults a policy, and nothing
+     * reaches a host: an unbound scheme is decided by a table read.
+     */
+    dispatch(parts) {
+        const scheme = parts.scheme ?? "";
+        const handler = this.handlers.handler(scheme);
+        return handler === undefined
+            ? { kind: "refused", reason: "resource-scheme-unbound" }
+            : { kind: "scheme", handler, parts };
     }
     storeRefusal(reason) {
         return Frame.error(`$!.${reason} ${this.toString()}`);