@atolljs/core 0.1.6 → 0.1.7

package/dist/contract/sharedMemory.d.ts

@@ -49,6 +49,8 @@ export interface ConnectorContext {
         view: Int32Array;
         index: number;
     };
+    /** The field's contract path — for devtools write events on granular commits. */
+    path?: string;
 }
 /**
  * A connector factory builds a connector for one field kind over a region of

package/dist/contract/types.d.ts

@@ -60,6 +60,8 @@ export interface WorkerPoolConfig<S extends SharedSpec = SharedSpec, T extends T
     persistence?: (memory: SharedMemory<S>) => MemoryPersistence | undefined;
     /** Worker count — a number, or 'auto' (the default) for navigator.hardwareConcurrency ?? 4. */
     poolSize?: number | 'auto';
+    /** Display label for devtools/dashboards — falls back to a generated id. */
+    name?: string;
     memory?: MemoryConfig;
     /** Max in-flight tasks per worker (default 1); excess tasks queue FIFO. */
     concurrency?: number;

package/dist/devtools.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Structured instrumentation events for the devtools/dashboard tooling.
+ * Same zero-cost contract as `log.ts` and islands' `proxyMetrics`: when no
+ * sink is installed, emit() is a single branch — production pays nothing.
+ *
+ * Events are emitted on whichever thread they occur on. Worker-side events
+ * reach the main thread's sink by postMessage forwarding (`ATOLL_DEVTOOLS`
+ * on the task channel — the pool re-emits them), so one sink sees the whole
+ * app. See docs/plans/devtools-dashboard.md.
+ */
+export type DevtoolsThread = 'main' | 'worker';
+export type TaskSettleOutcome = 'ok' | 'error' | 'aborted' | 'timeout' | 'queue-full' | 'crashed';
+export type DevtoolsEvent = {
+    type: 'pool:init';
+    poolId: string;
+    /** Config `name`, when supplied — a display label, not the id. */
+    label?: string;
+    poolSize: number;
+    concurrency: number;
+    memoryBytes?: number;
+} | {
+    type: 'pool:terminate';
+    poolId: string;
+} | {
+    type: 'worker:spawn';
+    poolId: string;
+    slot: number;
+} | {
+    type: 'worker:error';
+    poolId: string;
+    slot: number;
+    message: string;
+} | {
+    type: 'worker:respawn';
+    poolId: string;
+    slot: number;
+} | {
+    type: 'task:enqueue';
+    poolId: string;
+    callId: number;
+    taskId: string;
+} | {
+    type: 'task:dispatch';
+    poolId: string;
+    callId: number;
+    taskId: string;
+    slot: number;
+    waitMs: number;
+} | {
+    type: 'task:settle';
+    poolId: string;
+    callId: number;
+    taskId: string;
+    outcome: TaskSettleOutcome;
+    /** dispatch→reply; absent for calls that never ran. */
+    runMs?: number;
+    error?: string;
+} | {
+    type: 'memory:bind';
+    /** Version-counter index → field path, for pairing memory:write. */
+    fields: [index: number, path: string][];
+    totalBytes: number;
+} | {
+    type: 'memory:write';
+    path: string;
+    version: number;
+} | {
+    type: 'island:mount';
+    instance: string;
+    app: string;
+    pid: string;
+    /** The client pool driving this island — links the island to its worker. */
+    poolId?: string;
+    /** Renderer/framework tag supplied by the mounter — observability only. */
+    framework?: string;
+} | {
+    type: 'island:unmount';
+    instance: string;
+} | {
+    type: 'island:event';
+    instance: string;
+    name: string;
+} | {
+    type: 'island:task';
+    instance: string;
+    /** The client call behind the round-trip — the island's "request". */
+    method: 'mount' | 'whoami' | 'dispatch' | 'setSize' | 'updateProps' | 'flush' | 'unmount';
+    /** Round-trip ms: call → ops returned (worker render + transport). */
+    ms: number;
+    /** Op count in the returned batch (response size in ops). */
+    ops?: number;
+    error?: string;
+} | {
+    type: 'island:ops';
+    instance: string;
+    /** The client call that produced the batch. */
+    via: 'mount' | 'updateProps' | 'dispatch' | 'setSize' | 'flush' | 'unmount';
+    count: number;
+    /** Main-thread replay time; worker-side render time rides call timings. */
+    replayMs?: number;
+} | {
+    type: 'net:fetch';
+    /** Per-context sequence — correlates the net:fetch-detail follow-up. */
+    id: number;
+    url: string;
+    method: string;
+    /** HTTP status — absent when the request failed before a response. */
+    status?: number;
+    /** Time from dispatch to response headers (error: to failure). */
+    ms: number;
+    /** Response Content-Length when advertised. */
+    bytes?: number;
+    error?: string;
+    reqHeaders?: [string, string][];
+    /** Capped preview; non-text bodies are described, not dumped. */
+    reqBody?: string;
+} | {
+    /**
+     * Detail follow-up to net:fetch (same id) — emitted after the response
+     * settles so it can carry headers, a capped body preview, and the
+     * Resource Timing stage breakdown once the entry exists.
+     */
+    type: 'net:fetch-detail';
+    id: number;
+    /** Present when the body was only readable async (Request objects). */
+    reqBody?: string;
+    resHeaders?: [string, string][];
+    resBody?: string;
+    /**
+     * Stage ms from PerformanceResourceTiming: queue (stalled → fetch
+     * start), dns, tcp, tls, wait (request → first byte), download.
+     * Absent for cross-origin responses without Timing-Allow-Origin.
+     */
+    timing?: {
+        queue: number;
+        dns: number;
+        tcp: number;
+        tls: number;
+        wait: number;
+        download: number;
+    };
+    transferSize?: number;
+    encodedSize?: number;
+    decodedSize?: number;
+} | {
+    type: 'runtime:memory';
+    /**
+     * measureUserAgentSpecificMemory: cluster total.
+     * performance.memory / process.memoryUsage fallback: this context's
+     * usedJSHeapSize / heapUsed.
+     */
+    heapBytes: number;
+    heapLimitBytes?: number;
+    /** Resident set size — present on the Node memoryUsage() path. */
+    rssBytes?: number;
+    /**
+     * Per-execution-context attribution from
+     * `performance.measureUserAgentSpecificMemory` — emitted on the main
+     * thread only (workers can't self-identify among same-URL contexts).
+     * Worker contexts are identified by their script URL.
+     */
+    contexts?: {
+        bytes: number;
+        scope?: string;
+        url?: string;
+    }[];
+};
+export type EmittedDevtoolsEvent = DevtoolsEvent & {
+    /** performance.now() on the emitting thread. */
+    at: number;
+    /** Which side of the boundary emitted the event. */
+    thread: DevtoolsThread;
+    /**
+     * Stamped by the pool when re-emitting a worker-forwarded event —
+     * attributes worker-side events (memory writes, fetches, heap samples)
+     * to the specific pool slot that produced them.
+     */
+    worker?: {
+        poolId: string;
+        slot: number;
+    };
+};
+export type DevtoolsSink = (event: EmittedDevtoolsEvent) => void;
+/** Install the event sink (devtools transports hook here); null disables. */
+export declare const setDevtoolsSink: (custom: DevtoolsSink | null) => void;
+/** Emit a structured event — one branch when no sink is installed. */
+export declare const emitDevtools: (event: DevtoolsEvent) => void;
+/**
+ * Re-emit an already-stamped event — for forwarding worker-side events that
+ * arrived over postMessage without re-stamping their timing/thread.
+ */
+export declare const forwardDevtools: (event: EmittedDevtoolsEvent) => void;
+/** True when a devtools sink is installed on this thread. */
+export declare const devtoolsEnabled: () => boolean;
+/**
+ * Worker side: route emitted events to the main thread over the task
+ * channel (`ATOLL_DEVTOOLS` messages — the pool re-emits them into its
+ * sink). Switched on by the pool's INIT handshake when the pool has a
+ * sink installed, so workers only forward when someone is listening.
+ */
+export declare const enableWorkerDevtoolsForwarding: () => void;
+/**
+ * Wrap `scope.fetch` to emit `net:fetch` (+ a `net:fetch-detail` follow-up
+ * with headers/body previews and stage timings) for every request — covers
+ * main thread (installed by connectDevtools) and workers (installed by the
+ * INIT handshake's forwarding flag). Idempotent; restores nothing (the
+ * wrapper delegates to the captured original). XHR is not covered.
+ */
+export declare const installFetchProbe: (scope: {
+    fetch?: typeof fetch;
+}) => void;
+/**
+ * Emit `runtime:memory` periodically — JS heap usage. On the main thread,
+ * prefers `performance.measureUserAgentSpecificMemory()`, which reports a
+ * per-execution-context breakdown (windows + workers identified by script
+ * URL) for the whole agent cluster; falls back to `performance.memory`,
+ * which also covers the worker-side install on engines that expose it
+ * there, then `process.memoryUsage()` on Node (heapUsed + rss — works
+ * inside worker_threads too). No-ops with none of the three.
+ */
+export declare const installMemoryProbe: (scope: object, intervalMs?: number) => void;
+/** Process-unique ids for pools — 'pool-1', 'pool-2', … */
+export declare const nextDevtoolsId: (prefix: string) => string;

package/dist/index.d.ts

@@ -29,3 +29,5 @@ export { defineTask, isAsyncTask, toTask } from './task.js';
 export type { AsyncTask, TaskSnapshot } from './task.js';
 export { getLogLevel, log, scoped, setLogLevel, setLogSink } from './log.js';
 export type { LogEntry, LogLevel, LogSink } from './log.js';
+export { devtoolsEnabled, emitDevtools, installFetchProbe, installMemoryProbe, setDevtoolsSink, } from './devtools.js';
+export type { DevtoolsEvent, DevtoolsSink, DevtoolsThread, EmittedDevtoolsEvent, TaskSettleOutcome, } from './devtools.js';

package/dist/index.js

@@ -1,19 +1,20 @@
 import { msgpackrCodec as e } from "./index2.js";
 import { SchemaError as t, z as n } from "./index3.js";
 import { listSchema as r } from "./index4.js";
-import { getLogLevel as i, log as a, scoped as o, setLogLevel as s, setLogSink as c } from "./index5.js";
-import { bindSharedMemories as l, defineSharedMemory as u, field as d, getDefinedSharedMemoryCount as f, jsonCodec as p, registerConnectorFactory as m } from "./index6.js";
-import { reef as h } from "./index7.js";
-import { MemoryManager as g } from "./index8.js";
-import { PoolQueueFullError as _, TaskAbortedError as v, TaskTimeoutError as y, WorkerCrashedError as b } from "./index9.js";
-import { WorkerPool as x } from "./index10.js";
-import { connectWorker as S, workerClient as C } from "./index11.js";
-import { connectSharedWorker as w } from "./index12.js";
-import { TaskRegistry as T } from "./index13.js";
-import { sharedWorkerHost as E } from "./index14.js";
-import { createClient as D, defineService as O, implementService as k, rpc as A, serviceMethod as j } from "./index15.js";
-import { RESERVED_CLIENT_KEYS as M, defineWorker as N } from "./index17.js";
-import { reactive as P, shallowEqual as F, watch as I } from "./index18.js";
-import { observe as L } from "./index19.js";
-import { defineTask as R, isAsyncTask as z, toTask as B } from "./index20.js";
-export { g as MemoryManager, _ as PoolQueueFullError, M as RESERVED_CLIENT_KEYS, t as SchemaError, v as TaskAbortedError, T as TaskRegistry, y as TaskTimeoutError, b as WorkerCrashedError, x as WorkerPool, l as bindSharedMemories, w as connectSharedWorker, S as connectWorker, D as createClient, O as defineService, u as defineSharedMemory, R as defineTask, N as defineWorker, d as field, f as getDefinedSharedMemoryCount, i as getLogLevel, k as implementService, z as isAsyncTask, p as jsonCodec, r as listSchema, a as log, e as msgpackrCodec, L as observe, P as reactive, h as reef, m as registerConnectorFactory, A as rpc, o as scoped, j as serviceMethod, s as setLogLevel, c as setLogSink, F as shallowEqual, E as sharedWorkerHost, B as toTask, I as watch, C as workerClient, n as z };
+import { devtoolsEnabled as i, emitDevtools as a, installFetchProbe as o, installMemoryProbe as s, setDevtoolsSink as c } from "./index5.js";
+import { getLogLevel as l, log as u, scoped as d, setLogLevel as f, setLogSink as p } from "./index6.js";
+import { bindSharedMemories as m, defineSharedMemory as h, field as g, getDefinedSharedMemoryCount as _, jsonCodec as v, registerConnectorFactory as y } from "./index7.js";
+import { reef as b } from "./index8.js";
+import { MemoryManager as x } from "./index9.js";
+import { PoolQueueFullError as S, TaskAbortedError as C, TaskTimeoutError as w, WorkerCrashedError as T } from "./index10.js";
+import { WorkerPool as E } from "./index11.js";
+import { connectWorker as D, workerClient as O } from "./index12.js";
+import { connectSharedWorker as k } from "./index13.js";
+import { TaskRegistry as A } from "./index14.js";
+import { sharedWorkerHost as j } from "./index15.js";
+import { createClient as M, defineService as N, implementService as P, rpc as F, serviceMethod as I } from "./index16.js";
+import { RESERVED_CLIENT_KEYS as L, defineWorker as R } from "./index18.js";
+import { reactive as z, shallowEqual as B, watch as V } from "./index19.js";
+import { observe as H } from "./index20.js";
+import { defineTask as U, isAsyncTask as W, toTask as G } from "./index21.js";
+export { x as MemoryManager, S as PoolQueueFullError, L as RESERVED_CLIENT_KEYS, t as SchemaError, C as TaskAbortedError, A as TaskRegistry, w as TaskTimeoutError, T as WorkerCrashedError, E as WorkerPool, m as bindSharedMemories, k as connectSharedWorker, D as connectWorker, M as createClient, N as defineService, h as defineSharedMemory, U as defineTask, R as defineWorker, i as devtoolsEnabled, a as emitDevtools, g as field, _ as getDefinedSharedMemoryCount, l as getLogLevel, P as implementService, o as installFetchProbe, s as installMemoryProbe, W as isAsyncTask, v as jsonCodec, r as listSchema, u as log, e as msgpackrCodec, H as observe, z as reactive, b as reef, y as registerConnectorFactory, F as rpc, d as scoped, I as serviceMethod, c as setDevtoolsSink, f as setLogLevel, p as setLogSink, B as shallowEqual, j as sharedWorkerHost, G as toTask, V as watch, O as workerClient, n as z };

package/dist/index10.js

@@ -1,191 +1,20 @@
-import { fmtBytes as e, scoped as t } from "./index5.js";
-import { MemoryManager as n } from "./index8.js";
-import { PoolQueueFullError as r, TaskAbortedError as i, TaskTimeoutError as a, WorkerCrashedError as o } from "./index9.js";
-//#region src/pool/workerPool.ts
-var s = t("pool"), c = t("task"), l = () => ({
-	count: 0,
-	mean: 0,
-	max: 0,
-	add(e) {
-		this.count++, this.mean += (e - this.mean) / this.count, e > this.max && (this.max = e);
+//#region src/pool/errors.ts
+var e = class extends Error {
+	constructor(e = "WorkerPool task queue is full") {
+		super(e), this.name = "PoolQueueFullError";
 	}
-}), u = class {
-	slots = [];
-	pending = /* @__PURE__ */ new Map();
-	nextMessageId = 0;
-	queue = [];
-	memoryManager;
-	workerUrl;
-	spawn;
-	concurrency;
-	maxQueue;
-	respawn;
-	taskTimeout;
-	closed = !1;
-	drainWaiters = [];
-	statsAgg = {
-		completed: 0,
-		failed: 0,
-		aborted: 0,
-		waitMs: l(),
-		runMs: l()
-	};
-	sharedMemory;
-	persistence;
-	constructor(t) {
-		if (t.sharedMemory && (typeof SharedArrayBuffer > "u" || typeof crossOriginIsolated < "u" && !crossOriginIsolated)) throw Error("WorkerPool requires SharedArrayBuffer in a cross-origin isolated context — serve the page with COOP/COEP headers.");
-		if (!t.workerUrl && !t.createWorker) throw Error("WorkerPool requires either `workerUrl` or `createWorker` in its config.");
-		this.workerUrl = t.workerUrl, this.spawn = t.createWorker ?? (() => new Worker(this.workerUrl, { type: "module" })), this.concurrency = t.concurrency ?? 1, this.maxQueue = t.maxQueue ?? Infinity, this.respawn = t.respawn ?? !0, this.taskTimeout = t.taskTimeout, t.sharedMemory && (this.sharedMemory = t.sharedMemory, this.memoryManager = new n(t.memory), this.memoryManager.ensureCapacity(this.sharedMemory.totalBytes), this.sharedMemory.bind(this.memoryManager.getBuffer()), this.persistence = t.persistence?.(t.sharedMemory));
-		let r = t.poolSize ?? "auto", i = r === "auto" ? navigator.hardwareConcurrency ?? 4 : r;
-		s.info(this.sharedMemory ? `spawning ${i} worker(s) with ${e(this.sharedMemory.totalBytes)} shared buffer` : `spawning ${i} worker(s), message-only`, { workerUrl: t.workerUrl ? String(t.workerUrl) : "createWorker()" }), s.debug("tip: setLogLevel('trace') for per-task detail");
-		for (let e = 0; e < i; e++) this.addWorker(this.spawn());
-		let a = t.tasks ?? {};
-		for (let [e, t] of Object.entries(a)) {
-			if (e in this) {
-				s.warn(`task "${e}" collides with a WorkerPool member — not installed`);
-				continue;
-			}
-			this[e] = (...e) => this.runTask(t, ...e);
-		}
-		Object.keys(a).length > 0 && s.info(`task methods: ${Object.keys(a).join(", ")}`);
+}, t = class extends Error {
+	constructor(e = "task aborted") {
+		super(e), this.name = "AbortError";
 	}
-	addWorker(e) {
-		let t = {
-			worker: e,
-			inFlight: 0
-		};
-		return e.addEventListener("message", (e) => {
-			this.handleReply(t, e.data);
-		}), e.addEventListener("error", (e) => {
-			this.handleWorkerError(t, e);
-		}), this.memoryManager ? e.postMessage({
-			type: "INIT_MEMORY",
-			memory: this.memoryManager.memory
-		}) : e.postMessage({ type: "INIT" }), this.slots.push(t), s.debug(`worker spawned, ${this.memoryManager ? "INIT_MEMORY" : "INIT"} sent`), t;
+}, n = class extends Error {
+	constructor(e = "task timed out") {
+		super(e), this.name = "TaskTimeoutError";
 	}
-	handleReply(e, t) {
-		let n = t.messageId === void 0 ? void 0 : this.pending.get(t.messageId);
-		n && (this.pending.delete(t.messageId), e.inFlight--, this.detach(n), n.done || (n.done = !0, this.statsAgg.runMs.add(performance.now() - (n.sentAt ?? n.enqueuedAt)), t.success ? (this.statsAgg.completed++, c.debug(`← ${n.contract.taskId} ok`), n.resolve(t.result)) : (this.statsAgg.failed++, c.warn(`← ${n.contract.taskId} failed: ${t.error}`), n.reject(Error(t.error)))), this.drainQueue(), this.checkDrained());
-	}
-	handleWorkerError(e, t) {
-		if (this.closed) return;
-		let n = t, r = n?.message ?? (n?.error ? String(n.error) : "worker error");
-		s.warn(`worker error: ${r}`);
-		for (let [t, n] of [...this.pending]) if (n.slot === e) {
-			if (this.pending.delete(t), this.detach(n), n.done) continue;
-			n.done = !0, this.statsAgg.failed++, n.reject(new o(r));
-		}
-		let i = this.slots.indexOf(e);
-		if (i >= 0 && this.slots.splice(i, 1), e.worker.terminate(), this.respawn) s.info("respawning crashed worker"), this.addWorker(this.spawn());
-		else if (this.slots.length === 0) for (let e of this.queue.splice(0)) e.done = !0, this.detach(e), this.statsAgg.failed++, e.reject(new o(r));
-		this.drainQueue(), this.checkDrained();
-	}
-	pickWorker() {
-		let e;
-		for (let t of this.slots) t.inFlight >= this.concurrency || (!e || t.inFlight < e.inFlight) && (e = t);
-		return e;
-	}
-	drainQueue() {
-		let e;
-		for (; this.queue.length > 0 && (e = this.pickWorker());) {
-			let t = this.queue.shift();
-			t.done || this.send(e, t);
-		}
-	}
-	send(e, t) {
-		let n = this.nextMessageId++;
-		t.messageId = n, t.slot = e, t.sentAt = performance.now(), this.statsAgg.waitMs.add(performance.now() - t.enqueuedAt), e.inFlight++, this.pending.set(n, t), c.debug(`→ ${t.contract.taskId}`, {
-			worker: this.slots.indexOf(e),
-			args: t.args
-		}), e.worker.postMessage({
-			type: "EXECUTE_TASK",
-			messageId: n,
-			taskId: t.contract.taskId,
-			args: t.args
-		});
-	}
-	detach(e) {
-		e.timer && clearTimeout(e.timer), e.signal && e.onSignalAbort && e.signal.removeEventListener("abort", e.onSignalAbort);
-	}
-	cancel(e, t) {
-		if (e.done) return;
-		let n = this.queue.indexOf(e);
-		n >= 0 && this.queue.splice(n, 1), e.done = !0, this.detach(e), this.statsAgg.aborted++, e.reject(t), this.drainQueue(), this.checkDrained();
-	}
-	checkDrained() {
-		if (this.queue.length === 0 && this.pending.size === 0) {
-			let e = this.drainWaiters.splice(0);
-			for (let t of e) t();
-		}
-	}
-	dispatch(e, t, n) {
-		return this.closed || this.slots.length === 0 ? Promise.reject(new o("WorkerPool has been terminated — no workers available.")) : n?.signal?.aborted ? Promise.reject(new i()) : new Promise((o, s) => {
-			let c = {
-				contract: e,
-				args: t,
-				enqueuedAt: performance.now(),
-				resolve: o,
-				reject: s,
-				done: !1,
-				signal: n?.signal
-			};
-			n?.signal && (c.onSignalAbort = () => this.cancel(c, new i()), n.signal.addEventListener("abort", c.onSignalAbort, { once: !0 }));
-			let l = n?.timeout ?? this.taskTimeout;
-			l !== void 0 && (c.timer = setTimeout(() => this.cancel(c, new a()), l));
-			let u = this.pickWorker();
-			if (u) this.send(u, c);
-			else if (this.queue.length >= this.maxQueue) {
-				c.done = !0, this.detach(c), s(new r());
-				return;
-			} else this.queue.push(c);
-		});
-	}
-	runTask(e, ...t) {
-		return this.dispatch(e, t);
-	}
-	get sharedBuffer() {
-		return this.memoryManager?.getBuffer();
-	}
-	get workers() {
-		return this.slots.map((e) => e.worker);
-	}
-	stats() {
-		return {
-			workers: this.slots.length,
-			idle: this.slots.filter((e) => e.inFlight === 0).length,
-			inFlight: this.pending.size,
-			queued: this.queue.length,
-			completed: this.statsAgg.completed,
-			failed: this.statsAgg.failed,
-			aborted: this.statsAgg.aborted,
-			waitMs: {
-				count: this.statsAgg.waitMs.count,
-				mean: this.statsAgg.waitMs.mean,
-				max: this.statsAgg.waitMs.max
-			},
-			runMs: {
-				count: this.statsAgg.runMs.count,
-				mean: this.statsAgg.runMs.mean,
-				max: this.statsAgg.runMs.max
-			}
-		};
-	}
-	close() {
-		return this.queue.length === 0 && this.pending.size === 0 ? (this.terminate(), Promise.resolve()) : new Promise((e) => {
-			this.drainWaiters.push(() => {
-				this.terminate(), e();
-			});
-		});
-	}
-	terminate() {
-		this.closed = !0, this.persistence?.stop()?.catch?.((e) => s.warn("memory persistence stop failed", e)), s.info(`terminating ${this.slots.length} worker(s)`);
-		let e = new o("pool terminated");
-		for (let [, t] of this.pending) this.detach(t), !t.done && (t.done = !0, this.statsAgg.failed++, t.reject(e));
-		this.pending.clear();
-		for (let t of this.queue.splice(0)) t.done = !0, this.detach(t), this.statsAgg.failed++, t.reject(e);
-		for (let e of this.slots) e.worker.terminate();
-		this.slots = [], this.checkDrained();
+}, r = class extends Error {
+	constructor(e = "worker crashed") {
+		super(e), this.name = "WorkerCrashedError";
 	}
 };
 //#endregion
-export { u as WorkerPool };
+export { e as PoolQueueFullError, t as TaskAbortedError, n as TaskTimeoutError, r as WorkerCrashedError };