effect-start 0.22.1 → 0.23.0

package/dist/client/ScrollState.js

@@ -11,9 +11,7 @@ export function persist() {
         const element = document.elementFromPoint(0, y);
         if (!element)
             continue;
-        const target = element.id
-            ? element
-            : element.closest("[id]") ?? element;
+        const target = element.id ? element : (element.closest("[id]") ?? element);
         anchors.push({
             selector: selectorFromElement(target),
             offset: target.getBoundingClientRect().top,
@@ -88,9 +86,7 @@ function selectorFromElement(element) {
         const parent = current.parentElement;
         if (!parent)
             break;
-        const index = Array
-            .from(parent.children)
-            .indexOf(current) + 1;
+        const index = Array.from(parent.children).indexOf(current) + 1;
         parts.unshift(`${current.tagName.toLowerCase()}:nth-child(${index})`);
         current = parent;
     }

package/dist/client/index.js

@@ -3,7 +3,7 @@
  * It is responsible for live reloading the page when bundle changes.
  * When NODE_ENV=production, it does nothing.
  */
-import { showBuildError } from "./Overlay.js";
+import * as Overlay from "./Overlay.js";
 import * as ScrollState from "./ScrollState.js";
 const BUNDLE_URL = globalThis._BUNDLE_URL ?? "/_bundle";
 function reload() {
@@ -11,11 +11,9 @@ function reload() {
     window.location.reload();
 }
 async function loadAllEntrypoints() {
-    const manifest = await fetch(`/${BUNDLE_URL}/manifest.json`)
-        .then(v => v.json());
-    manifest
-        .artifacts
-        .filter(v => v.path.endsWith(".js"))
+    const manifest = await fetch(`/${BUNDLE_URL}/manifest.json`).then((v) => v.json());
+    manifest.artifacts
+        .filter((v) => v.path.endsWith(".js"))
         .forEach((artifact) => {
         console.log(artifact.path);
         const script = document.createElement("script");
@@ -34,7 +32,7 @@ function handleBundleEvent(event) {
             reload();
             break;
         case "BuildError":
-            showBuildError(event.error);
+            Overlay.showBuildError(event.error);
             break;
     }
 }
@@ -53,7 +51,7 @@ function listen() {
             });
         }
     });
-    eventSource.addEventListener("error", error => {
+    eventSource.addEventListener("error", (error) => {
         console.error("SSE connection error:", error);
     });
     return () => {

package/dist/console/Console.d.ts

@@ -0,0 +1,6 @@
+import * as Layer from "effect/Layer";
+import * as Route from "../Route.ts";
+import * as ConsoleStore from "./ConsoleStore.ts";
+export { ConsoleStore } from "./ConsoleStore.ts";
+export declare function layer(options?: ConsoleStore.ConsoleStoreOptions): Layer.Layer<ConsoleStore.ConsoleStore>;
+export declare function routeLayer(prefix: string): Layer.Layer<Route.Routes, never, Route.Routes | ConsoleStore.ConsoleStore>;

package/dist/console/Console.js

@@ -0,0 +1,26 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Route from "../Route.js";
+import * as RouteTree from "../RouteTree.js";
+import * as ConsoleErrors from "./ConsoleErrors.js";
+import * as ConsoleLogger from "./ConsoleLogger.js";
+import * as ConsoleMetrics from "./ConsoleMetrics.js";
+import * as ConsoleProcess from "./ConsoleProcess.js";
+import * as ConsoleStore from "./ConsoleStore.js";
+import * as ConsoleTracer from "./ConsoleTracer.js";
+import consoleRoutes from "./routes/tree.js";
+export { ConsoleStore } from "./ConsoleStore.js";
+export function layer(options) {
+    const store = ConsoleStore.layer(options);
+    return Layer.mergeAll(ConsoleTracer.layer, ConsoleLogger.layer, ConsoleMetrics.layer, ConsoleErrors.layer, ConsoleProcess.layer).pipe(Layer.provideMerge(store));
+}
+export function routeLayer(prefix) {
+    return Layer.effect(Route.Routes, Effect.gen(function* () {
+        const existing = yield* Route.Routes;
+        ConsoleStore.store.prefix = prefix;
+        const tree = Route.tree({
+            [prefix]: consoleRoutes,
+        });
+        return RouteTree.merge(existing, tree);
+    }));
+}

package/dist/console/ConsoleErrors.d.ts

@@ -0,0 +1,3 @@
+import * as Layer from "effect/Layer";
+import * as ConsoleStore from "./ConsoleStore.ts";
+export declare const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore>;

package/dist/console/ConsoleErrors.js

@@ -0,0 +1,200 @@
+import * as Cause from "effect/Cause";
+import * as Chunk from "effect/Chunk";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as FiberId from "effect/FiberId";
+import * as FiberRef from "effect/FiberRef";
+import * as HashMap from "effect/HashMap";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as PubSub from "effect/PubSub";
+import * as Supervisor from "effect/Supervisor";
+import * as ConsoleStore from "./ConsoleStore.js";
+let errorId = 0;
+function safeSerialize(value, depth = 0) {
+    if (depth > 4)
+        return "<deep>";
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === "bigint")
+        return `${value}n`;
+    if (typeof value === "function")
+        return undefined;
+    if (typeof value === "symbol")
+        return value.toString();
+    if (typeof value !== "object")
+        return value;
+    if (value instanceof Date)
+        return value.toISOString();
+    if (value instanceof Error)
+        return value.message;
+    if (Array.isArray(value))
+        return value.slice(0, 20).map((v) => safeSerialize(v, depth + 1));
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== null && proto !== Object.prototype) {
+        if (typeof value._tag === "string") {
+            return serializeTaggedObject(value, depth);
+        }
+        return `<${proto.constructor?.name ?? "object"}>`;
+    }
+    return serializePlainObject(value, depth);
+}
+function serializePlainObject(obj, depth) {
+    const out = {};
+    let count = 0;
+    for (const [k, v] of Object.entries(obj)) {
+        if (count >= 20)
+            break;
+        if (typeof v === "function")
+            continue;
+        const serialized = safeSerialize(v, depth + 1);
+        if (serialized !== undefined) {
+            out[k] = serialized;
+            count++;
+        }
+    }
+    return out;
+}
+function serializeTaggedObject(obj, depth) {
+    const out = { _tag: obj._tag };
+    let count = 0;
+    for (const [k, v] of Object.entries(obj)) {
+        if (count >= 20)
+            break;
+        if (k === "_tag")
+            continue;
+        if (typeof v === "function")
+            continue;
+        if (k === "stack" || k === "name")
+            continue;
+        const serialized = safeSerialize(v, depth + 1);
+        if (serialized !== undefined) {
+            out[k] = serialized;
+            count++;
+        }
+    }
+    return out;
+}
+function extractTag(error) {
+    if (error !== null &&
+        typeof error === "object" &&
+        "_tag" in error &&
+        typeof error._tag === "string") {
+        return error._tag;
+    }
+    return undefined;
+}
+function extractMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    const tag = extractTag(error);
+    if (tag)
+        return tag;
+    try {
+        return String(error);
+    }
+    catch {
+        return "<unknown>";
+    }
+}
+function extractProperties(error) {
+    if (error === null || error === undefined || typeof error !== "object")
+        return {};
+    const out = {};
+    let count = 0;
+    for (const [k, v] of Object.entries(error)) {
+        if (count >= 20)
+            break;
+        if (k === "_tag" || k === "stack" || k === "name")
+            continue;
+        if (typeof v === "function")
+            continue;
+        const serialized = safeSerialize(v, 0);
+        if (serialized !== undefined) {
+            out[k] = serialized;
+            count++;
+        }
+    }
+    return out;
+}
+const spanSymbol = Symbol.for("effect/SpanAnnotation");
+function extractSpanName(error) {
+    if (error !== null && typeof error === "object" && spanSymbol in error) {
+        const span = error[spanSymbol];
+        return typeof span?.name === "string" ? span.name : undefined;
+    }
+    return undefined;
+}
+function extractDetails(cause) {
+    const details = [];
+    const failures = Chunk.toArray(Cause.failures(cause));
+    for (const error of failures) {
+        details.push({
+            kind: "fail",
+            tag: extractTag(error),
+            message: extractMessage(error),
+            properties: extractProperties(error),
+            span: extractSpanName(error),
+        });
+    }
+    const defects = Chunk.toArray(Cause.defects(cause));
+    for (const defect of defects) {
+        details.push({
+            kind: "die",
+            tag: extractTag(defect),
+            message: extractMessage(defect),
+            properties: extractProperties(defect),
+            span: extractSpanName(defect),
+        });
+    }
+    return details;
+}
+function make(store) {
+    return new (class extends Supervisor.AbstractSupervisor {
+        value = Effect.void;
+        onStart(_context, _effect, parent, fiber) {
+            const childId = FiberId.threadName(fiber.id());
+            if (Option.isSome(parent)) {
+                const parentId = FiberId.threadName(parent.value.id());
+                if (childId !== parentId) {
+                    store.fiberParents.set(childId, parentId);
+                }
+            }
+            const span = fiber.currentSpan;
+            const annotations = {};
+            const spanAnnotations = fiber.getFiberRef(FiberRef.currentTracerSpanAnnotations);
+            HashMap.forEach(spanAnnotations, (value, key) => {
+                annotations[key] = value;
+            });
+            const logAnnotations = fiber.getFiberRef(FiberRef.currentLogAnnotations);
+            HashMap.forEach(logAnnotations, (value, key) => {
+                annotations[key] = value;
+            });
+            store.fiberContexts.set(childId, {
+                spanName: span?._tag === "Span" ? span.name : undefined,
+                traceId: span ? span.traceId : undefined,
+                annotations,
+            });
+        }
+        onEnd(exit, fiber) {
+            if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
+                const error = {
+                    id: String(++errorId),
+                    date: new Date(),
+                    fiberId: FiberId.threadName(fiber.id()),
+                    interrupted: Cause.isInterrupted(exit.cause),
+                    prettyPrint: Cause.pretty(exit.cause, { renderErrorCause: true }),
+                    details: extractDetails(exit.cause),
+                };
+                store.errors.push(error);
+                Effect.runSync(PubSub.publish(store.events, { _tag: "Error", error }));
+            }
+        }
+    })();
+}
+export const layer = Layer.unwrapEffect(Effect.gen(function* () {
+    const store = yield* ConsoleStore.ConsoleStore;
+    return Supervisor.addSupervisor(make(store));
+}));

package/dist/console/ConsoleLogger.d.ts

@@ -0,0 +1,3 @@
+import * as Layer from "effect/Layer";
+import * as ConsoleStore from "./ConsoleStore.ts";
+export declare const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore>;

package/dist/console/ConsoleLogger.js

@@ -0,0 +1,47 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as FiberId from "effect/FiberId";
+import * as FiberRef from "effect/FiberRef";
+import * as HashMap from "effect/HashMap";
+import * as HashSet from "effect/HashSet";
+import * as Layer from "effect/Layer";
+import * as List from "effect/List";
+import * as Logger from "effect/Logger";
+import * as PubSub from "effect/PubSub";
+import * as ConsoleStore from "./ConsoleStore.js";
+let logId = 0;
+export const layer = Layer.effectDiscard(Effect.gen(function* () {
+    const store = yield* ConsoleStore.ConsoleStore;
+    const logger = Logger.make(({ message, logLevel, cause, fiberId, spans, annotations, date }) => {
+        const levelMap = {
+            Debug: "DEBUG",
+            Info: "INFO",
+            Warning: "WARNING",
+            Error: "ERROR",
+            Fatal: "FATAL",
+        };
+        const level = levelMap[logLevel._tag] ?? "INFO";
+        const causeStr = !Cause.isEmpty(cause)
+            ? Cause.pretty(cause, { renderErrorCause: true })
+            : undefined;
+        const spanNames = [];
+        List.forEach(spans, (s) => spanNames.push(s.label));
+        const ann = {};
+        HashMap.forEach(annotations, (v, k) => {
+            ann[k] = v;
+        });
+        const log = {
+            id: String(++logId),
+            date,
+            level,
+            message: String(message),
+            fiberId: FiberId.threadName(fiberId),
+            cause: causeStr,
+            spans: spanNames,
+            annotations: ann,
+        };
+        store.logs.push(log);
+        Effect.runSync(PubSub.publish(store.events, { _tag: "Log", log }));
+    });
+    yield* FiberRef.update(FiberRef.currentLoggers, (loggers) => HashSet.add(loggers, logger));
+}));

package/dist/console/ConsoleMetrics.d.ts

@@ -0,0 +1,3 @@
+import * as Layer from "effect/Layer";
+import * as ConsoleStore from "./ConsoleStore.ts";
+export declare const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore>;

package/dist/console/ConsoleMetrics.js

@@ -0,0 +1,61 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Metric from "effect/Metric";
+import * as MetricKeyType from "effect/MetricKeyType";
+import * as PubSub from "effect/PubSub";
+import * as Schedule from "effect/Schedule";
+import * as ConsoleStore from "./ConsoleStore.js";
+export const layer = Layer.scopedDiscard(Effect.gen(function* () {
+    const store = yield* ConsoleStore.ConsoleStore;
+    yield* Effect.forkScoped(Effect.schedule(Effect.sync(() => {
+        const pairs = Metric.unsafeSnapshot();
+        const snapshots = [];
+        for (const pair of pairs) {
+            const key = pair.metricKey;
+            const state = pair.metricState;
+            let type = "counter";
+            let value = 0;
+            if (MetricKeyType.CounterKeyTypeTypeId in key.keyType) {
+                type = "counter";
+                value = state.count;
+            }
+            else if (MetricKeyType.GaugeKeyTypeTypeId in key.keyType) {
+                type = "gauge";
+                value = state.value;
+            }
+            else if (MetricKeyType.HistogramKeyTypeTypeId in key.keyType) {
+                type = "histogram";
+                value = {
+                    buckets: state.buckets,
+                    count: state.count,
+                    sum: state.sum,
+                    min: state.min,
+                    max: state.max,
+                };
+            }
+            else if (MetricKeyType.FrequencyKeyTypeTypeId in key.keyType) {
+                type = "frequency";
+                value = Object.fromEntries(state.occurrences);
+            }
+            else if (MetricKeyType.SummaryKeyTypeTypeId in key.keyType) {
+                type = "summary";
+                value = {
+                    quantiles: state.quantiles,
+                    count: state.count,
+                    sum: state.sum,
+                    min: state.min,
+                    max: state.max,
+                };
+            }
+            snapshots.push({
+                name: key.name,
+                type,
+                value,
+                tags: key.tags.map((t) => ({ key: t.key, value: t.value })),
+                timestamp: Date.now(),
+            });
+        }
+        store.metrics = snapshots;
+        Effect.runSync(PubSub.publish(store.events, { _tag: "MetricsSnapshot", metrics: snapshots }));
+    }), Schedule.spaced("2 seconds")));
+}));

package/dist/console/ConsoleProcess.d.ts

@@ -0,0 +1,3 @@
+import * as Layer from "effect/Layer";
+import * as ConsoleStore from "./ConsoleStore.ts";
+export declare const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore>;

package/dist/console/ConsoleProcess.js

@@ -0,0 +1,49 @@
+import * as NOS from "node:os";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as PubSub from "effect/PubSub";
+import * as Schedule from "effect/Schedule";
+import * as ConsoleStore from "./ConsoleStore.js";
+function snapshot() {
+    const mem = process.memoryUsage();
+    const cpu = process.cpuUsage();
+    const res = process.resourceUsage();
+    const loadavg = NOS.loadavg();
+    return {
+        pid: process.pid,
+        uptime: process.uptime(),
+        memory: {
+            rss: mem.rss,
+            heapUsed: mem.heapUsed,
+            heapTotal: mem.heapTotal,
+            external: mem.external,
+            arrayBuffers: mem.arrayBuffers,
+        },
+        cpu: { user: cpu.user, system: cpu.system },
+        resourceUsage: {
+            maxRSS: res.maxRSS,
+            minorPageFault: res.minorPageFault,
+            majorPageFault: res.majorPageFault,
+            fsRead: res.fsRead,
+            fsWrite: res.fsWrite,
+            voluntaryContextSwitches: res.voluntaryContextSwitches,
+            involuntaryContextSwitches: res.involuntaryContextSwitches,
+        },
+        system: {
+            loadavg,
+            freemem: NOS.freemem(),
+            totalmem: NOS.totalmem(),
+            cpuCount: NOS.cpus().length,
+            platform: NOS.platform(),
+            arch: NOS.arch(),
+        },
+    };
+}
+export const layer = Layer.scopedDiscard(Effect.gen(function* () {
+    const store = yield* ConsoleStore.ConsoleStore;
+    yield* Effect.forkScoped(Effect.schedule(Effect.sync(() => {
+        const stats = snapshot();
+        store.process = stats;
+        Effect.runSync(PubSub.publish(store.events, { _tag: "ProcessSnapshot", stats }));
+    }), Schedule.spaced("2 seconds")));
+}));

package/dist/console/ConsoleStore.d.ts

@@ -0,0 +1,144 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as PubSub from "effect/PubSub";
+export declare const store: ConsoleStoreShape;
+export interface ConsoleSpan {
+    readonly spanId: string;
+    readonly traceId: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly parentSpanId: string | undefined;
+    startTime: bigint;
+    endTime: bigint | undefined;
+    durationMs: number | undefined;
+    status: "started" | "ok" | "error";
+    readonly attributes: Record<string, unknown>;
+    readonly events: Array<{
+        name: string;
+        startTime: bigint;
+        attributes?: Record<string, unknown>;
+    }>;
+}
+export interface ConsoleLog {
+    readonly id: string;
+    readonly date: Date;
+    readonly level: "DEBUG" | "INFO" | "WARNING" | "ERROR" | "FATAL";
+    readonly message: string;
+    readonly fiberId: string;
+    readonly cause: string | undefined;
+    readonly spans: Array<string>;
+    readonly annotations: Record<string, unknown>;
+}
+export interface ProcessStats {
+    readonly pid: number;
+    readonly uptime: number;
+    readonly memory: {
+        readonly rss: number;
+        readonly heapUsed: number;
+        readonly heapTotal: number;
+        readonly external: number;
+        readonly arrayBuffers: number;
+    };
+    readonly cpu: {
+        readonly user: number;
+        readonly system: number;
+    };
+    readonly resourceUsage: {
+        readonly maxRSS: number;
+        readonly minorPageFault: number;
+        readonly majorPageFault: number;
+        readonly fsRead: number;
+        readonly fsWrite: number;
+        readonly voluntaryContextSwitches: number;
+        readonly involuntaryContextSwitches: number;
+    };
+    readonly system: {
+        readonly loadavg: readonly [number, number, number];
+        readonly freemem: number;
+        readonly totalmem: number;
+        readonly cpuCount: number;
+        readonly platform: string;
+        readonly arch: string;
+    };
+}
+export interface ConsoleErrorDetail {
+    readonly kind: "fail" | "die";
+    readonly tag: string | undefined;
+    readonly message: string;
+    readonly properties: Record<string, unknown>;
+    readonly span: string | undefined;
+}
+export interface ConsoleError {
+    readonly id: string;
+    readonly date: Date;
+    readonly fiberId: string;
+    readonly interrupted: boolean;
+    readonly prettyPrint: string;
+    readonly details: Array<ConsoleErrorDetail>;
+}
+export interface ConsoleMetricSnapshot {
+    readonly name: string;
+    readonly type: "counter" | "gauge" | "histogram" | "summary" | "frequency";
+    readonly value: unknown;
+    readonly tags: ReadonlyArray<{
+        key: string;
+        value: string;
+    }>;
+    readonly timestamp: number;
+}
+export type ConsoleEvent = {
+    readonly _tag: "SpanStart";
+    readonly span: ConsoleSpan;
+} | {
+    readonly _tag: "SpanEnd";
+    readonly span: ConsoleSpan;
+} | {
+    readonly _tag: "Log";
+    readonly log: ConsoleLog;
+} | {
+    readonly _tag: "Error";
+    readonly error: ConsoleError;
+} | {
+    readonly _tag: "MetricsSnapshot";
+    readonly metrics: Array<ConsoleMetricSnapshot>;
+} | {
+    readonly _tag: "ProcessSnapshot";
+    readonly stats: ProcessStats;
+};
+export declare class CircularBuffer<T> {
+    private buffer;
+    private head;
+    private count;
+    capacity: number;
+    constructor(capacity: number);
+    push(item: T): void;
+    toArray(): Array<T>;
+    get size(): number;
+}
+export interface FiberContext {
+    readonly spanName: string | undefined;
+    readonly traceId: string | undefined;
+    readonly annotations: Record<string, unknown>;
+}
+export interface ConsoleStoreShape {
+    prefix: string;
+    readonly spans: CircularBuffer<ConsoleSpan>;
+    readonly logs: CircularBuffer<ConsoleLog>;
+    readonly errors: CircularBuffer<ConsoleError>;
+    metrics: Array<ConsoleMetricSnapshot>;
+    process: ProcessStats | undefined;
+    readonly events: PubSub.PubSub<ConsoleEvent>;
+    readonly fiberParents: Map<string, string>;
+    readonly fiberContexts: Map<string, FiberContext>;
+}
+export declare function fiberIdCounter(): number;
+declare const ConsoleStore_base: Context.TagClass<ConsoleStore, "effect-start/ConsoleStore", ConsoleStoreShape>;
+export declare class ConsoleStore extends ConsoleStore_base {
+}
+export interface ConsoleStoreOptions {
+    readonly spanCapacity?: number;
+    readonly logCapacity?: number;
+    readonly errorCapacity?: number;
+}
+export declare function layer(options?: ConsoleStoreOptions): Layer.Layer<ConsoleStore>;
+export {};

package/dist/console/ConsoleStore.js

@@ -0,0 +1,61 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as GlobalValue from "effect/GlobalValue";
+import * as Layer from "effect/Layer";
+import * as MutableRef from "effect/MutableRef";
+import * as PubSub from "effect/PubSub";
+export const store = GlobalValue.globalValue(Symbol.for("effect-start/ConsoleStore"), () => ({
+    prefix: "/console",
+    spans: new CircularBuffer(1000),
+    logs: new CircularBuffer(5000),
+    errors: new CircularBuffer(1000),
+    metrics: [],
+    process: undefined,
+    events: Effect.runSync(PubSub.unbounded()),
+    fiberParents: new Map(),
+    fiberContexts: new Map(),
+}));
+export class CircularBuffer {
+    buffer;
+    head = 0;
+    count = 0;
+    capacity;
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.buffer = Array.from({ length: capacity });
+    }
+    push(item) {
+        this.buffer[this.head] = item;
+        this.head = (this.head + 1) % this.capacity;
+        if (this.count < this.capacity)
+            this.count++;
+    }
+    toArray() {
+        if (this.count === 0)
+            return [];
+        const result = [];
+        const start = this.count < this.capacity ? 0 : this.head;
+        for (let i = 0; i < this.count; i++) {
+            result.push(this.buffer[(start + i) % this.capacity]);
+        }
+        return result;
+    }
+    get size() {
+        return this.count;
+    }
+}
+export function fiberIdCounter() {
+    const counter = GlobalValue.globalValue(Symbol.for("effect/Fiber/Id/_fiberCounter"), () => MutableRef.make(0));
+    return MutableRef.get(counter);
+}
+export class ConsoleStore extends Context.Tag("effect-start/ConsoleStore")() {
+}
+export function layer(options) {
+    if (options?.spanCapacity)
+        store.spans = new CircularBuffer(options.spanCapacity);
+    if (options?.logCapacity)
+        store.logs = new CircularBuffer(options.logCapacity);
+    if (options?.errorCapacity)
+        store.errors = new CircularBuffer(options.errorCapacity);
+    return Layer.sync(ConsoleStore, () => store);
+}