@aethervtt/shard-runtime 0.0.1 → 0.2.0

package/dist/perf.js

@@ -0,0 +1,245 @@
+import {
+  clockInfo,
+  defineResource,
+  ProfilerResource,
+  ShardError,
+  spanCovers,
+  spanStats,
+  TRACK,
+  trackName
+} from "@aethervtt/shard-core";
+const PerfHostResource = defineResource("runtime/PerfHost", {
+  description: "The host's profiling instruments (0074): heap, GC, sampling, and where traces go."
+});
+const PerfProviders = defineResource("runtime/PerfProviders", {
+  description: "What packages add to perf.describe and capture summaries: GPU memory, sections.",
+  init: () => ({ sections: /* @__PURE__ */ new Map() })
+});
+const r3 = (ms) => Math.round(ms * 1e3) / 1e3;
+function rounded(a) {
+  const out = {
+    span: a.span,
+    last: r3(a.last),
+    avg: r3(a.avg),
+    p50: r3(a.p50),
+    p95: r3(a.p95),
+    max: r3(a.max),
+    samples: a.samples
+  };
+  if (a.coarse) out.coarse = true;
+  return out;
+}
+function heapOf(world) {
+  const fromHost = world.tryResource(PerfHostResource)?.heap?.();
+  if (fromHost) return fromHost;
+  const g = globalThis;
+  const usage = g.process?.memoryUsage?.();
+  if (usage) return { usedBytes: usage.heapUsed, totalBytes: usage.heapTotal, source: "v8" };
+  const memory = g.performance?.memory;
+  if (memory) {
+    return {
+      usedBytes: memory.usedJSHeapSize,
+      totalBytes: memory.totalJSHeapSize,
+      limitBytes: memory.jsHeapSizeLimit,
+      source: "performance.memory"
+    };
+  }
+  return void 0;
+}
+function perfMemory(world) {
+  const gpu = world.tryResource(PerfProviders)?.gpuMemory?.(world) ?? { bytes: 0, byCategory: {} };
+  const heap = heapOf(world);
+  return heap ? { gpu, heap } : { gpu };
+}
+const OVERLAP_RATIO = 1.1;
+function isGpuPass(name) {
+  return name.startsWith("gpu:") && name !== "gpu:frame" && !name.startsWith("gpu:span/");
+}
+function gpuPassOverlap(profiler) {
+  const frame = profiler.timing("gpu:frame");
+  if (!frame || frame.avg <= 0) return void 0;
+  let passes = 0;
+  for (const name of profiler.names()) {
+    if (isGpuPass(name)) passes += profiler.timing(name).avg;
+  }
+  return {
+    passesMs: r3(passes),
+    frameMs: r3(frame.avg),
+    overlapping: passes > frame.avg * OVERLAP_RATIO
+  };
+}
+function describePerf(world, options = {}) {
+  const profiler = world.resource(ProfilerResource);
+  const keys = options.spans;
+  const top = options.top ?? 30;
+  const wanted = (name) => !keys || keys.some((k) => spanCovers(k, name));
+  const byTrack = { main: [], gpu: [], worker: [], async: [] };
+  const schedules = {};
+  const commands = {};
+  for (const name of profiler.names()) {
+    if (!wanted(name)) continue;
+    const stats = spanStats(profiler, name);
+    if (name.startsWith("schedule/")) schedules[name] = rounded(stats);
+    else if (name.startsWith("commands/")) commands[name] = rounded(stats);
+    else if (name !== "frame" && name !== "gpu:frame") byTrack[stats.track]?.push(stats);
+  }
+  const list = (track) => (byTrack[track] ?? []).sort((a, b) => b.avg - a.avg || (a.span < b.span ? -1 : 1)).slice(0, top).map(rounded);
+  const frame = spanStats(profiler, "frame");
+  const gpuFrame = spanStats(profiler, "gpu:frame");
+  const overlap = gpuPassOverlap(profiler);
+  const clock = clockInfo();
+  const ecs = world.stats();
+  let ecsBytes = 0;
+  for (const t of ecs.tables) ecsBytes += t.bytes;
+  const providers = world.tryResource(PerfProviders);
+  const sections = {};
+  for (const [name, fn] of providers?.sections ?? []) sections[name] = fn(world);
+  return {
+    enabled: profiler.enabled,
+    window: profiler.window,
+    clock: {
+      resolutionMs: clock.resolutionMs,
+      isolated: clock.isolated,
+      /** Spans that average under this read mostly the clock's step (`coarse`). */
+      coarseBelowMs: r3(clock.resolutionMs * 4)
+    },
+    frame: frame ? rounded(frame) : null,
+    schedules,
+    commands,
+    systems: list("main"),
+    gpu: profiler.gpu.status === "unavailable" ? "unavailable" : {
+      frame: gpuFrame ? rounded(gpuFrame) : null,
+      quantized: profiler.gpu.quantized,
+      // 0075: pass times that add up to more than the frame overlap, and don't rank passes.
+      overlapping: overlap?.overlapping ?? false,
+      ...overlap?.overlapping ? {
+        passesMs: overlap.passesMs,
+        note: "Pass times overlap (a tile-based GPU): each includes waiting for earlier work, so they sum past gpu:frame and do not rank passes. perf.ablate measures what each pass costs."
+      } : {},
+      passes: list("gpu")
+    },
+    workers: list("worker"),
+    async: list("async"),
+    memory: {
+      ...perfMemory(world),
+      ecs: { entities: ecs.entities, archetypes: ecs.archetypes, bytes: ecsBytes }
+    },
+    ...sections
+  };
+}
+function captureStamp(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+function perfBreakdown(world, limit = 10) {
+  const profiler = world.resource(ProfilerResource);
+  const cpu = [];
+  const gpu = [];
+  for (const name of profiler.names()) {
+    if (name === "frame" || name === "gpu:frame") continue;
+    const a = spanStats(profiler, name);
+    const stats = {
+      span: name,
+      track: a.track,
+      calls: a.samples,
+      total: r3(a.avg * a.samples),
+      p50: r3(a.p50),
+      p95: r3(a.p95),
+      max: r3(a.max)
+    };
+    (a.track === "gpu" ? gpu : cpu).push(stats);
+  }
+  const order = (x, y) => y.p95 - x.p95 || (x.span < y.span ? -1 : 1);
+  return { cpu: cpu.sort(order).slice(0, limit), gpu: gpu.sort(order).slice(0, limit) };
+}
+const gcNames = /* @__PURE__ */ new Map();
+async function capturePerf(world, options = {}) {
+  const profiler = world.resource(ProfilerResource);
+  if (profiler.sink) {
+    throw new ShardError("perf/capture-running", "A capture is already running on this app", {
+      hint: "Wait for it to finish, then capture again."
+    });
+  }
+  const { startCapture } = await import("@aethervtt/shard-core/capture");
+  const host = world.tryResource(PerfHostResource);
+  const warnings = [];
+  let sampler;
+  if (options.sample) {
+    sampler = await host?.startSampler?.();
+    if (!sampler) {
+      warnings.push(
+        new ShardError("perf/sampling-unavailable", "This host can't sample JavaScript", {
+          hint: "Node samples with node:inspector; browsers need the JS Self-Profiling API and a Document-Policy: js-profiling header (shard dev and the playground send it)."
+        }).toJSON()
+      );
+    }
+  }
+  const measure = host?.measure;
+  const { step, sample: _, devtools, write, trace: wantTrace, keep, ...captureOptions } = options;
+  const recorder = startCapture(profiler, {
+    ...captureOptions,
+    devtools: devtools && measure ? (name, track, start, ms) => measure(name, trackName(track), start, ms) : void 0
+  });
+  const offGc = host?.onGc?.((start, ms, kind) => {
+    let name = gcNames.get(kind);
+    if (!name) {
+      name = `gc/${kind}`;
+      gcNames.set(kind, name);
+    }
+    profiler.event(name, TRACK.gc, start, ms);
+  });
+  let capture;
+  try {
+    if (step) {
+      while (recorder.running) await step();
+    } else {
+      const limitMs = ((options.timeout ?? 60) + (options.frames ?? 300) / 10) * 1e3;
+      const timer = setTimeout(() => recorder.stop(), limitMs);
+      try {
+        await recorder.done;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    capture = await recorder.done;
+  } catch (err) {
+    recorder.stop();
+    throw err;
+  } finally {
+    offGc?.();
+  }
+  const sampled = sampler ? await sampler.stop() : void 0;
+  const summary = capture.summary({
+    clock: { ...clockInfo(), gpuQuantized: profiler.gpu.quantized },
+    memory: perfMemory(world),
+    hottest: sampled?.hottest,
+    warnings
+  });
+  const result = { summary };
+  if (keep) result.capture = capture;
+  if (wantTrace === false) return result;
+  const trace = capture.trace({ samples: sampled?.samples });
+  if (write !== false && host?.writeText) {
+    const stamp = captureStamp();
+    result.tracePath = `.shard/captures/${stamp}.trace.json`;
+    await host.writeText(result.tracePath, JSON.stringify(trace));
+    if (sampled?.cpuprofile) {
+      result.profilePath = `.shard/captures/${stamp}.cpuprofile`;
+      await host.writeText(result.profilePath, JSON.stringify(sampled.cpuprofile));
+    }
+  } else {
+    result.trace = trace;
+  }
+  return result;
+}
+export {
+  OVERLAP_RATIO,
+  PerfHostResource,
+  PerfProviders,
+  capturePerf,
+  captureStamp,
+  describePerf,
+  gpuPassOverlap,
+  isGpuPass,
+  perfBreakdown,
+  perfMemory
+};

package/dist/plugin.d.ts

@@ -14,5 +14,17 @@ export interface Plugin {
     build(app: App): void;
     /** Optional async setup (e.g. loading WASM), awaited before Startup. */
     ready?(app: App): Promise<void> | void;
+    /**
+     * Releases what `build` and `ready` created that outlives the app: GPU objects, surfaces, DOM
+     * listeners, observers, workers. `app.dispose()` calls it in reverse build order, after the
+     * runner stopped (0052).
+     */
+    dispose?(app: App): Promise<void> | void;
+    /**
+     * Waits for work the plugin started that is still in flight (GPU commands submitted but not
+     * done). `app.dispose()` awaits it on every plugin before any plugin's `dispose`, so nothing is
+     * released while still in use: render's dispose runs last, after others freed their buffers.
+     */
+    beforeDispose?(app: App): Promise<void> | void;
 }
 export declare function definePlugin(plugin: Plugin): Plugin;

package/dist/runners.d.ts

@@ -11,13 +11,28 @@ export declare function headlessRunner(options: HeadlessOptions): Runner;
 export interface AnimationFrameOptions {
     /** Longest delta passed to update, in seconds, e.g. after the tab was hidden. Default 0.25. */
     maxDelta?: number;
-    /** Stops the loop when aborted. */
+    /** Stops the loop when aborted. `app.dispose()` stops it too. */
     signal?: AbortSignal;
     /**
      * Time a few idle frames before the first update to measure the display's refresh rate into
      * DisplayRate (about 12 refreshes: 0.1 s at 120 Hz). Default true.
      */
     measureRefresh?: boolean;
+    /**
+     * continuous (default): a frame every display refresh. on-demand: a frame only when something
+     * changed (0052): a world write, a FrameDemand holder or timer, input, a surface resize, queued
+     * steps, or `app.requestFrame()`. Idle, it requests no animation frames at all.
+     */
+    mode?: 'continuous' | 'on-demand';
+    /**
+     * On-demand, for dev builds: every second while idle, compare the plain-object resources marked
+     * `hostWritable` with their values when the app went idle, and log
+     * `runtime/unmarked-resource-write` for one that changed without waking it. Default false.
+     */
+    checkResourceWrites?: boolean;
 }
-/** Runs a frame per `requestAnimationFrame`. For the browser and Studio. */
+/**
+ * Runs frames on `requestAnimationFrame`, for the browser and Studio: one per display refresh, or
+ * in `mode: 'on-demand'` only while something needs them (0052).
+ */
 export declare function animationFrameRunner(options?: AnimationFrameOptions): Runner;

package/dist/runners.js

@@ -1,4 +1,5 @@
 import { AppControlResource } from "./control.js";
+import { FrameDemand } from "./demand.js";
 import { RefreshMeter, rateFromIntervals } from "./display.js";
 import { LogResource } from "./log.js";
 import { DisplayRate } from "./time.js";
@@ -9,76 +10,157 @@ function headlessRunner(options) {
   };
 }
 const PROBE_INTERVALS = 12;
-function probeRefresh() {
+function probeRefresh(probe) {
   return new Promise((resolve) => {
     if (document.hidden) return resolve(0);
     const intervals = new Float64Array(PROBE_INTERVALS);
     let last = -1;
     let n = 0;
     const tick = (t) => {
-      if (document.hidden) return resolve(0);
+      if (probe.stopped || document.hidden) return resolve(0);
       if (last >= 0) intervals[n++] = t - last;
       last = t;
-      if (n < PROBE_INTERVALS) requestAnimationFrame(tick);
+      if (n < PROBE_INTERVALS) probe.handle = requestAnimationFrame(tick);
       else resolve(rateFromIntervals(intervals));
     };
-    requestAnimationFrame(tick);
+    probe.handle = requestAnimationFrame(tick);
   });
 }
 function animationFrameRunner(options = {}) {
   const maxDelta = options.maxDelta ?? 0.25;
+  const onDemand = options.mode === "on-demand";
   return async (app) => {
-    const display = app.world.tryResource(DisplayRate);
-    if (display && options.measureRefresh !== false) {
-      const hz = await probeRefresh();
+    const world = app.world;
+    const demand = world.resource(FrameDemand);
+    const control = world.resource(AppControlResource);
+    const display = world.tryResource(DisplayRate);
+    const probe = { handle: 0, stopped: false };
+    let handle = 0;
+    let pending = false;
+    let idle = true;
+    let last;
+    let timer;
+    let writes;
+    let finish = () => {
+    };
+    const finished = new Promise((resolve) => {
+      finish = resolve;
+    });
+    const schedule = () => {
+      if (pending || probe.stopped) return;
+      pending = true;
+      handle = requestAnimationFrame(frame);
+    };
+    const onTimer = () => {
+      timer = void 0;
+      schedule();
+    };
+    const armTimer = () => {
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      const due = demand.dueIn();
+      if (due !== Number.POSITIVE_INFINITY) timer = setTimeout(onTimer, due);
+    };
+    const goIdle = () => {
+      idle = true;
+      world.asleep = true;
+      armTimer();
+      writes?.start();
+    };
+    const onVisibility = () => {
+      if (document.hidden) last = void 0;
+    };
+    const stop = () => {
+      if (probe.stopped) return;
+      probe.stopped = true;
+      cancelAnimationFrame(probe.handle);
+      if (pending) cancelAnimationFrame(handle);
+      pending = false;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      writes?.stop();
+      document.removeEventListener("visibilitychange", onVisibility);
+      options.signal?.removeEventListener("abort", stop);
+      if (onDemand) {
+        world.onWake = void 0;
+        world.asleep = false;
+        demand.onDemand = void 0;
+      }
+      demand.mode = "manual";
+      finish();
+    };
+    const meter = new RefreshMeter(display?.periodMs ?? 1e3 / 60);
+    const frame = (timestamp) => {
+      pending = false;
+      if (probe.stopped) return;
+      const woke = idle;
+      idle = false;
+      writes?.stop();
+      let delta = last === void 0 ? 0 : Math.min((timestamp - last) / 1e3, maxDelta);
+      if (onDemand) {
+        world.asleep = false;
+        demand.takeDue();
+        if (woke && last !== void 0) {
+          delta = 1 / app.fixedHz;
+          app.resetFixedTime();
+        }
+      }
+      if (display && last !== void 0 && !woke) {
+        const hz = meter.sample(timestamp - last);
+        if (hz > 0) {
+          display.hz = hz;
+          display.periodMs = 1e3 / hz;
+          display.source = "measured";
+        }
+      }
+      last = timestamp;
+      try {
+        if (!control.paused) app.update(delta);
+        else if (control.pendingSteps > 0) {
+          app.update(1 / app.fixedHz);
+          control.stepped();
+        }
+      } catch (err) {
+        world.resource(LogResource).error(err);
+        control.paused = true;
+        control.pausedByError = true;
+        control.abort(err);
+        console.error(err);
+      }
+      if (probe.stopped) return;
+      if (!onDemand || demand.active || control.pendingSteps > 0) schedule();
+      if (!pending) goIdle();
+    };
+    options.signal?.addEventListener("abort", stop);
+    app.attachDriver({ requestFrame: onDemand ? schedule : () => {
+    }, stop });
+    demand.mode = onDemand ? "on-demand" : "continuous";
+    if (options.signal?.aborted) stop();
+    if (display && options.measureRefresh !== false && !probe.stopped) {
+      const hz = await probeRefresh(probe);
       if (hz > 0) {
         display.hz = hz;
         display.periodMs = 1e3 / hz;
         display.source = "measured";
+        meter.periodMs = display.periodMs;
       }
     }
-    const meter = new RefreshMeter(display?.periodMs ?? 1e3 / 60);
-    return new Promise((resolve) => {
-      let last;
-      let handle = 0;
-      const onVisibility = () => {
-        if (document.hidden) last = void 0;
-      };
-      const frame = (timestamp) => {
-        const delta = last === void 0 ? 0 : Math.min((timestamp - last) / 1e3, maxDelta);
-        if (display && last !== void 0) {
-          const hz = meter.sample(timestamp - last);
-          if (hz > 0) {
-            display.hz = hz;
-            display.periodMs = 1e3 / hz;
-            display.source = "measured";
-          }
-        }
-        last = timestamp;
-        const control = app.world.resource(AppControlResource);
-        try {
-          if (!control.paused) app.update(delta);
-          else if (control.pendingSteps > 0) {
-            app.update(1 / app.fixedHz);
-            control.stepped();
-          }
-        } catch (err) {
-          app.world.resource(LogResource).error(err);
-          control.paused = true;
-          control.pausedByError = true;
-          control.abort(err);
-          console.error(err);
-        }
-        handle = requestAnimationFrame(frame);
+    if (onDemand && options.checkResourceWrites) {
+      const { ResourceWriteCheck } = await import("./write-check.js");
+      writes = new ResourceWriteCheck(world, world.tryResource(LogResource), () => idle && !pending);
+    }
+    if (probe.stopped) return;
+    if (onDemand) {
+      world.onWake = schedule;
+      demand.onDemand = () => {
+        if (!idle || probe.stopped) return;
+        if (demand.active) schedule();
+        else armTimer();
       };
-      document.addEventListener("visibilitychange", onVisibility);
-      options.signal?.addEventListener("abort", () => {
-        cancelAnimationFrame(handle);
-        document.removeEventListener("visibilitychange", onVisibility);
-        resolve();
-      });
-      handle = requestAnimationFrame(frame);
-    });
+    }
+    document.addEventListener("visibilitychange", onVisibility);
+    schedule();
+    return finished;
   };
 }
 export {

package/dist/scenario.d.ts

@@ -0,0 +1,9 @@
+export interface PerfScenarioData {
+    /** A scenario of budgets.json, or null: no scenario, so nothing adapts to a slice. */
+    name: string | null;
+}
+/**
+ * The scenario the app declares (`App.perfScenario`): features that adapt (0045's foliage) take
+ * their slice of its frame as their target, and the `perf` overlay shows its slices.
+ */
+export declare const PerfScenario: import("@aethervtt/shard-core").ResourceDef<PerfScenarioData>;

package/dist/scenario.js

@@ -0,0 +1,9 @@
+import { defineResource } from "@aethervtt/shard-core";
+const PerfScenario = defineResource("runtime/PerfScenario", {
+  description: "The budget scenario the app runs as (0075): features adapt to its slices, and the perf overlay shows them. null: none.",
+  hostWritable: true,
+  init: () => ({ name: null })
+});
+export {
+  PerfScenario
+};

package/dist/testing.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A stand-in for the browser's frame loop, so `animationFrameRunner` runs headless in tests: it
+ * installs `requestAnimationFrame`, `cancelAnimationFrame`, and (when there's none) a visible
+ * `document` on globalThis. Frames only run when the test ticks.
+ */
+export interface FakeFrames {
+    /** Animation frames requested so far. */
+    readonly requested: number;
+    /** Callbacks waiting for the next frame. */
+    readonly pending: number;
+    /** The timestamp the last tick passed, in ms. */
+    readonly now: number;
+    /** `visibilitychange` listeners on the fake document. */
+    readonly listeners: number;
+    /** Advances the clock by `ms` (default one 60 Hz refresh) and runs what was waiting. */
+    tick(ms?: number): number;
+    /** Ticks until nothing waits or `max` frames ran; returns the frames run. */
+    runUntilIdle(max?: number, ms?: number): number;
+    /** Puts the real globals back. */
+    restore(): void;
+}
+export declare function fakeAnimationFrames(): FakeFrames;

package/dist/testing.js

@@ -0,0 +1,64 @@
+function fakeAnimationFrames() {
+  const g = globalThis;
+  const saved = {
+    raf: g.requestAnimationFrame,
+    caf: g.cancelAnimationFrame,
+    document: g.document
+  };
+  let waiting = /* @__PURE__ */ new Map();
+  let nextId = 1;
+  let requested = 0;
+  let now = 0;
+  let listeners = 0;
+  g.requestAnimationFrame = (fn) => {
+    const id = nextId++;
+    requested++;
+    waiting.set(id, fn);
+    return id;
+  };
+  g.cancelAnimationFrame = (id) => {
+    waiting.delete(id);
+  };
+  if (saved.document === void 0) {
+    g.document = {
+      hidden: false,
+      addEventListener: () => void listeners++,
+      removeEventListener: () => void listeners--
+    };
+  }
+  const tick = (ms = 1e3 / 60) => {
+    now += ms;
+    const run = waiting;
+    waiting = /* @__PURE__ */ new Map();
+    for (const fn of run.values()) fn(now);
+    return run.size;
+  };
+  return {
+    get requested() {
+      return requested;
+    },
+    get pending() {
+      return waiting.size;
+    },
+    get now() {
+      return now;
+    },
+    get listeners() {
+      return listeners;
+    },
+    tick,
+    runUntilIdle(max = 1e4, ms) {
+      let frames = 0;
+      while (waiting.size > 0 && frames < max) frames += tick(ms);
+      return frames;
+    },
+    restore() {
+      g.requestAnimationFrame = saved.raf;
+      g.cancelAnimationFrame = saved.caf;
+      g.document = saved.document;
+    }
+  };
+}
+export {
+  fakeAnimationFrames
+};

package/dist/time.d.ts

@@ -32,3 +32,7 @@ export interface DisplayRateData {
 }
 export declare const DisplayRate: import("@aethervtt/shard-core").ResourceDef<DisplayRateData>;
 export declare const GlobalRng: import("@aethervtt/shard-core").ResourceDef<Rng>;
+/** Whether this is a development build (`new App({ dev: true })`). */
+export declare const DevMode: import("@aethervtt/shard-core").ResourceDef<{
+    enabled: boolean;
+}>;

package/dist/time.js

@@ -11,7 +11,12 @@ const DisplayRate = defineResource("core/DisplayRate", {
 const GlobalRng = defineResource("core/GlobalRng", {
   description: "The app root random stream, seeded from AppOptions.seed. Fork it per system."
 });
+const DevMode = defineResource("runtime/DevMode", {
+  description: "Development build: loud fallbacks and dev-only checks.",
+  init: () => ({ enabled: false })
+});
 export {
+  DevMode,
   DisplayRate,
   FixedTime,
   GlobalRng,

package/dist/write-check.d.ts

@@ -0,0 +1,22 @@
+import { type World } from '@aethervtt/shard-core';
+import type { Log } from './log.js';
+/**
+ * The on-demand runner's dev check (0052): while the app is idle, every second, compare the
+ * plain-object resources marked `hostWritable` with their values when it went idle, and log
+ * `runtime/unmarked-resource-write` for one that changed without waking the app. Loaded only when
+ * `checkResourceWrites` is on, so production builds don't carry it.
+ */
+export declare class ResourceWriteCheck {
+    private readonly snapshots;
+    private timer;
+    private readonly world;
+    private readonly log;
+    private readonly quiet;
+    /** `quiet`: still idle with no frame requested, so a change nobody announced is a bug. */
+    constructor(world: World, log: Log | undefined, quiet: () => boolean);
+    /** The app went idle: remember what the resources hold, and check them every second. */
+    start(): void;
+    /** A frame is running (or the loop stopped): writes are fine again. */
+    stop(): void;
+    private verify;
+}