@synnaxlabs/client 0.57.3 → 0.58.0

package/src/framer/cache/static.ts

@@ -46,12 +46,19 @@ export interface StaticProps {
    * be marked as stale and subject to garbage collection.
    * @default TimeSpan.seconds(20) */
   staleEntryThreshold?: TimeSpan;
+  /**
+   * Sets how long a fetched span counts as answered before it is refetched. Bounds
+   * the refetch rate of spans that stay empty, as every refetch opens a short-lived
+   * iterator connection.
+   * @default TimeSpan.minutes(10) */
+  staleCoverageThreshold?: TimeSpan;
 }
 
 export const DEFAULT_STATIC_PROPS: Required<StaticProps> = {
   instrumentation: alamos.NOOP,
   transform: IDENTITY_TRANSFORM,
   staleEntryThreshold: TimeSpan.seconds(20),
+  staleCoverageThreshold: TimeSpan.minutes(10),
 };
 
 interface CacheEntry {
@@ -61,6 +68,13 @@ interface CacheEntry {
   addedAt: TimeStamp;
 }
 
+interface CoveredRange {
+  /** The fetched span, held even when the fetch returned no samples. */
+  range: TimeRange;
+  /** When the fetch completed. Coverage answers gaps until it goes stale. */
+  addedAt: TimeStamp;
+}
+
 /**
  * A cache for historical channel data that will not be modified after it is written.
  * Fetched and streamed entries are held apart because they measure position in
@@ -71,6 +85,9 @@ interface CacheEntry {
 export class Static {
   private fetched: CacheEntry[] = [];
   private streamed: CacheEntry[] = [];
+  // Sorted, non-overlapping spans already fetched, kept apart from the entries so a
+  // span that returned no samples still counts as answered and is not refetched.
+  private covered: CoveredRange[] = [];
   private readonly props: Required<StaticProps>;
 
   constructor(props: StaticProps) {
@@ -78,8 +95,14 @@ export class Static {
       instrumentation = DEFAULT_STATIC_PROPS.instrumentation,
       transform = DEFAULT_STATIC_PROPS.transform,
       staleEntryThreshold = DEFAULT_STATIC_PROPS.staleEntryThreshold,
+      staleCoverageThreshold = DEFAULT_STATIC_PROPS.staleCoverageThreshold,
     } = props;
-    this.props = { instrumentation, transform, staleEntryThreshold };
+    this.props = {
+      instrumentation,
+      transform,
+      staleEntryThreshold,
+      staleCoverageThreshold,
+    };
   }
 
   /**
@@ -98,6 +121,36 @@ export class Static {
     this.repairIntegrity(series, entries);
   }
 
+  /**
+   * Records tr as fetched, merging it into the covered set. A covered span counts
+   * as answered even when empty, so it is refetched once it goes stale, not per read.
+   */
+  markFetched(tr: TimeRange): void {
+    if (!tr.isValid || tr.span.isZero) return;
+    let { start, end } = tr;
+    // Live merges keep the oldest stamp so a rolling read cannot refresh its own
+    // coverage forever. Stale records drop, so a refetch restarts their clock.
+    let addedAt = TimeStamp.now();
+    const keep: CoveredRange[] = [];
+    for (const c of this.covered) {
+      if (!this.isLive(c)) continue;
+      if (c.range.end.before(start) || c.range.start.after(end)) keep.push(c);
+      else {
+        if (c.range.start.before(start)) start = c.range.start;
+        if (c.range.end.after(end)) end = c.range.end;
+        if (c.addedAt.before(addedAt)) addedAt = c.addedAt;
+      }
+    }
+    keep.push({ range: new TimeRange(start, end), addedAt });
+    keep.sort((a, b) => TimeRange.sort(a.range, b.range));
+    this.covered = keep;
+  }
+
+  // Coverage answers gaps only until it goes stale. gc merely prunes dead records.
+  private isLive(c: CoveredRange): boolean {
+    return TimeStamp.since(c.addedAt).lessThan(this.props.staleCoverageThreshold);
+  }
+
   // Containment, not overlap: a fetch stamped wider than the data it returned
   // (an uncommitted tail) must not evict streamed samples it did not replace.
   private evictStreamed(written: MultiSeries): void {
@@ -125,11 +178,12 @@ export class Static {
       entries.filter((e) => e.data.timeRange.overlapsWith(tr)).map((e) => e.data);
     const fetched = overlapping(this.fetched);
     const series = [...fetched, ...overlapping(this.streamed)];
-    if (fetched.length === 0) return { series: new MultiSeries(series), gaps: [tr] };
+    if (fetched.length === 0)
+      return { series: new MultiSeries(series), gaps: this.subtractCovered(tr) };
     const gaps: TimeRange[] = [];
     const pushGap = (start: TimeStamp, end: TimeStamp): void => {
       const gap = new TimeRange(start, end);
-      if (gap.isValid && !gap.span.isZero) gaps.push(gap);
+      if (gap.isValid && !gap.span.isZero) gaps.push(...this.subtractCovered(gap));
     };
     pushGap(tr.start, fetched[0].timeRange.start);
     for (let i = 1; i < fetched.length; i++)
@@ -138,6 +192,29 @@ export class Static {
     return { series: new MultiSeries(series), gaps };
   }
 
+  // Removes the covered portions of gap, returning the still-unanswered remainder.
+  private subtractCovered(gap: TimeRange): TimeRange[] {
+    let remaining = [gap];
+    for (const c of this.covered) {
+      if (!this.isLive(c)) continue;
+      const { range } = c;
+      const next: TimeRange[] = [];
+      for (const r of remaining) {
+        if (!range.overlapsWith(r)) {
+          next.push(r);
+          continue;
+        }
+        const before = new TimeRange(r.start, range.start);
+        const after = new TimeRange(range.end, r.end);
+        if (before.isValid && !before.span.isZero) next.push(before);
+        if (after.isValid && !after.span.isZero) next.push(after);
+      }
+      remaining = next;
+      if (remaining.length === 0) break;
+    }
+    return remaining;
+  }
+
   /**
    * Garbage collects the cache, removing any stale entries.
    * @returns metrics about the garbage collection.
@@ -158,6 +235,11 @@ export class Static {
       });
     this.fetched = collect(this.fetched);
     this.streamed = collect(this.streamed);
+    // The client cannot tell "no data yet" from "no data ever" (backfill is legal),
+    // so stale coverage re-opens an empty span to one cheap fetch per staleness
+    // window instead of one per read (space-heater mode). Series purging above is not
+    // affected.
+    this.covered = this.covered.filter((c) => this.isLive(c));
     return res;
   }
 
@@ -165,6 +247,7 @@ export class Static {
   close(): void {
     this.fetched = [];
     this.streamed = [];
+    this.covered = [];
   }
 
   private writeOne(series: Series, entries: CacheEntry[]): void {

package/src/framer/cache/unary.ts

@@ -70,6 +70,13 @@ export class Unary {
     this.static.write(series);
   }
 
+  /** Records tr as fetched so reads stop reporting it as a gap even when it holds no
+   * samples. Call after a fetch for tr completes. */
+  markFetched(tr: TimeRange): void {
+    this.checkOpen("markFetched");
+    this.static.markFetched(tr);
+  }
+
   /**
    * Reads cached data overlapping the given time range. The result includes the live
    * leading buffer when the data it actually holds overlaps the range, judged by the

package/src/framer/feed.ts

@@ -52,6 +52,7 @@ export class Feed {
       dynamicBufferSize,
       gcInterval,
       staleEntryThreshold,
+      staleCoverageThreshold,
       removalDelay,
       breaker,
       batchDebounce,
@@ -62,6 +63,7 @@ export class Feed {
       dynamicBufferSize,
       gcInterval,
       staleEntryThreshold,
+      staleCoverageThreshold,
       instrumentation: instrumentation?.child("cache"),
     });
     this.reader = new Reader({

package/src/framer/writer.ts

@@ -146,9 +146,9 @@ const authorityParamsZ = z
     control.authorityZ.optional(),
   ])
   .transform(([value, authority]) => {
-    if (control.authorityZ.safeParse(value).success)
-      return { keys: [], authorities: [value as control.Authority] };
-    if (keyZ.or(nameZ).safeParse(value).success) {
+    if (z.validate(control.authorityZ, value))
+      return { keys: [], authorities: [value] };
+    if (z.validate(keyZ.or(nameZ), value)) {
       if (authority == null)
         throw new Error(
           "authority is required when setting authority for a single channel",
@@ -158,8 +158,7 @@ const authorityParamsZ = z
         authorities: [authority],
       };
     }
-    const oValue = value as Record<channel.Key | channel.Name, control.Authority>;
-    return { keys: Object.keys(oValue), authorities: Object.values(oValue) };
+    return { keys: Object.keys(value), authorities: Object.values(value) };
   });
 
 /**

package/src/index.ts

@@ -7,6 +7,8 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import "zod/compile";
+
 export { access } from "@/access";
 export type { Policy } from "@/access/policy/types.gen";
 export type { Role } from "@/access/role/types.gen";

package/src/lineplot/actions.gen.ts

@@ -16,6 +16,7 @@ import { actions } from "@/actions";
 import { channel } from "@/channel";
 import {
   axisKeyZ,
+  customRangeZ,
   downsampleModeZ,
   keyZ,
   type LinePlot,
@@ -154,6 +155,16 @@ export const setRangesPayloadZ = z.object({
 
 export type SetRangesPayload = z.infer<typeof setRangesPayloadZ>;
 
+/**
+ * SetCustomRange sets the window the "custom" range key resolves to. A null custom
+ * clears the window.
+ */
+export const setCustomRangePayloadZ = z.object({
+  custom: zod.nullToUndefined(customRangeZ),
+});
+
+export type SetCustomRangePayload = z.infer<typeof setCustomRangePayloadZ>;
+
 /** SetAxisLabel sets the label rendered along the axis identified by key. */
 export const setAxisLabelPayloadZ = z.object({
   key: axisKeyZ,
@@ -380,6 +391,10 @@ export const actionZ = z.discriminatedUnion("type", [
   z.object({ type: z.literal("add_range"), addRange: addRangePayloadZ }),
   z.object({ type: z.literal("remove_range"), removeRange: removeRangePayloadZ }),
   z.object({ type: z.literal("set_ranges"), setRanges: setRangesPayloadZ }),
+  z.object({
+    type: z.literal("set_custom_range"),
+    setCustomRange: setCustomRangePayloadZ,
+  }),
   z.object({ type: z.literal("set_axis_label"), setAxisLabel: setAxisLabelPayloadZ }),
   z.object({
     type: z.literal("set_axis_label_direction"),
@@ -536,6 +551,15 @@ export const setRanges = (payload: z.input<typeof setRangesPayloadZ>): Action =>
   }),
 });
 
+export const setCustomRange = (
+  payload: z.input<typeof setCustomRangePayloadZ>,
+): Action => ({
+  type: "set_custom_range",
+  setCustomRange: zod.parse(setCustomRangePayloadZ, payload, {
+    label: "line plot set_custom_range action payload",
+  }),
+});
+
 export const setAxisLabel = (
   payload: z.input<typeof setAxisLabelPayloadZ>,
 ): Action => ({
@@ -748,6 +772,10 @@ export interface Handlers {
   addRange: (state: Draft<LinePlot>, payload: AddRangePayload) => HandlerResult;
   removeRange: (state: Draft<LinePlot>, payload: RemoveRangePayload) => HandlerResult;
   setRanges: (state: Draft<LinePlot>, payload: SetRangesPayload) => HandlerResult;
+  setCustomRange: (
+    state: Draft<LinePlot>,
+    payload: SetCustomRangePayload,
+  ) => HandlerResult;
   setAxisLabel: (state: Draft<LinePlot>, payload: SetAxisLabelPayload) => HandlerResult;
   setAxisLabelDirection: (
     state: Draft<LinePlot>,
@@ -830,6 +858,8 @@ export const createReduceAll = (handlers: Handlers) =>
         return handlers.removeRange(state, action.removeRange);
       case "set_ranges":
         return handlers.setRanges(state, action.setRanges);
+      case "set_custom_range":
+        return handlers.setCustomRange(state, action.setCustomRange);
       case "set_axis_label":
         return handlers.setAxisLabel(state, action.setAxisLabel);
       case "set_axis_label_direction":

package/src/lineplot/actions.ts

@@ -25,6 +25,7 @@ import {
   setAxisTickSpacing,
   setAxisType,
   setChannels,
+  setCustomRange,
   setLegendHidden,
   setLegendPosition,
   setLine,
@@ -261,6 +262,19 @@ const handlers: Handlers = {
     };
   },
 
+  setCustomRange: (state, payload) => {
+    const old = state.ranges.custom;
+    state.ranges.custom = payload.custom;
+    return {
+      inverse: [
+        setCustomRange({
+          custom: old === undefined ? undefined : actions.snapshotDraft(old),
+        }),
+      ],
+      targets: ["range:custom"],
+    };
+  },
+
   setAxisLabel: (state, payload) => {
     const axis = state.axes[payload.key];
     const inverse = [setAxisLabel({ key: payload.key, label: axis.label })];

package/src/lineplot/types.gen.ts

@@ -9,7 +9,7 @@
 
 // Code generated by Oracle. DO NOT EDIT.
 
-import { color, spatial, text, uuid } from "@synnaxlabs/x";
+import { color, spatial, telem, text, uuid, zod } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { channel } from "@/channel";
@@ -81,26 +81,6 @@ export const channelsZ = z.object({
 });
 export interface Channels extends z.infer<typeof channelsZ> {}
 
-/** Ranges binds range keys to each x-axis. */
-export const rangesZ = z.object({
-  /**
-   * x1 are the range keys plotted against the x1 axis. Range keys are opaque strings
-   * rather than UUIDs because the console layers synthetic rolling-window ranges (e.g.
-   * "recent", "rolling1m") alongside persisted ranges; the server stores whatever the
-   * client sends.
-   */
-  x1: z
-    .string()
-    .array()
-    .default(() => []),
-  /** x2 are the range keys plotted against the x2 axis. */
-  x2: z
-    .string()
-    .array()
-    .default(() => []),
-});
-export interface Ranges extends z.infer<typeof rangesZ> {}
-
 /**
  * ManualBounds controls whether an axis uses a manually-set bound on each side
  * independently. When a side is false (the default), the corresponding entry in
@@ -175,6 +155,42 @@ export interface Rule extends z.infer<typeof ruleZ> {}
 export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
 
+/** DynamicCustomRange is a rolling window. */
+export const dynamicCustomRangeZ = z.object({
+  variant: z.literal("dynamic"),
+  /** span is the span of the window, which ends now. */
+  span: telem.numericTimeSpanZ.default(0),
+});
+export interface DynamicCustomRange extends z.infer<typeof dynamicCustomRangeZ> {}
+
+/** StaticCustomRange is a fixed window. */
+export const staticCustomRangeZ = z.object({
+  variant: z.literal("static"),
+  /** start is the inclusive start of the fixed window. */
+  start: telem.stringTimeStampZ,
+  /** end is the exclusive end of the fixed window. */
+  end: telem.stringTimeStampZ,
+});
+export interface StaticCustomRange extends z.infer<typeof staticCustomRangeZ> {}
+
+export const CUSTOM_RANGE_TYPES = ["dynamic", "static"] as const;
+export const customRangeTypeZ = z.enum(CUSTOM_RANGE_TYPES);
+export type CustomRangeType = z.infer<typeof customRangeTypeZ>;
+
+/** CustomRange is the window a plot's synthetic "custom" range key resolves to. */
+export const customRangeZ = z.discriminatedUnion("variant", [
+  dynamicCustomRangeZ,
+  staticCustomRangeZ,
+]);
+export type CustomRange = DynamicCustomRange | StaticCustomRange;
+
+export const CUSTOM_RANGE_SCHEMAS: {
+  [K in CustomRangeType]: z.ZodType<Extract<CustomRange, { variant: K }>>;
+} = {
+  dynamic: dynamicCustomRangeZ,
+  static: staticCustomRangeZ,
+};
+
 /** Axis is the configuration for a single plot axis. */
 export const axisZ = z.object({
   /** key identifies which of the six axes this configuration applies to. */
@@ -203,6 +219,28 @@ export const axisZ = z.object({
 });
 export interface Axis extends z.infer<typeof axisZ> {}
 
+/** Ranges binds range keys to each x-axis. */
+export const rangesZ = z.object({
+  /**
+   * x1 are the range keys plotted against the x1 axis. Range keys are opaque strings
+   * rather than UUIDs because the console layers synthetic rolling-window ranges (e.g.
+   * "recent", "rolling1m") alongside persisted ranges; the server stores whatever the
+   * client sends.
+   */
+  x1: z
+    .string()
+    .array()
+    .default(() => []),
+  /** x2 are the range keys plotted against the x2 axis. */
+  x2: z
+    .string()
+    .array()
+    .default(() => []),
+  /** custom is the window the "custom" range key resolves to. */
+  custom: zod.nullToUndefined(customRangeZ),
+});
+export interface Ranges extends z.infer<typeof rangesZ> {}
+
 /** Axes bundles configuration for all six fixed plot axes. */
 export const axesZ = z.object({
   /** x1 is the x1 axis configuration. */

package/src/panel/client.ts

@@ -263,8 +263,6 @@ export class Client extends query.Retriever<typeof retrieveMultiParamsZ, Key, Pa
     );
   }
 
-  async delete(key: Key, opts?: query.WriteOptions): Promise<void>;
-  async delete(keys: Key[], opts?: query.WriteOptions): Promise<void>;
   async delete(keys: Key | Key[], opts: query.WriteOptions = {}): Promise<void> {
     const keysArr = array.toArray(keys);
     const drop = () => [

package/src/project/client.ts

@@ -182,8 +182,6 @@ export class Client extends query.Retriever<typeof retrieveMultiParamsZ, Key, Pr
     this.mergeThrough(key, { layout });
   }
 
-  async delete(key: Key, opts?: query.WriteOptions): Promise<void>;
-  async delete(keys: Key[], opts?: query.WriteOptions): Promise<void>;
   async delete(keys: Key | Key[], opts: query.WriteOptions = {}): Promise<void> {
     const keysArr = array.toArray(keys);
     const drop = () => [

package/src/query/indexes.ts

@@ -29,13 +29,11 @@ export class LookupIndex<
     this.extract = extract;
   }
 
-  /** Returns the entries whose extracted index value equals the given value. */
-  get(value: IndexValue): Value[];
   /**
-   * Returns the entries matching any of the given values, in the order of the
-   * values and each entry once.
+   * Returns the entries whose extracted index value equals the given value. Given an
+   * array, returns the entries matching any of the values, in the order of the values
+   * and each entry once.
    */
-  get(values: IndexValue[]): Value[];
   get(value: IndexValue | IndexValue[]): Value[] {
     if (Array.isArray(value))
       return Array.from(new Set(value)).flatMap((v) => this.get(v));

package/src/query/table.ts

@@ -312,11 +312,10 @@ export class Table<
     return this.set(arr);
   }
 
-  /** Returns every entry in the table. */
-  get(): Value[];
+  /** Returns every entry in the table, or every entry the filter accepts. */
+  get(filter?: (value: Value) => boolean): Value[];
   get(key: Key): Value | undefined;
   get(keys: Key[]): Value[];
-  get(filter: (value: Value) => boolean): Value[];
   get(keys?: Key | Key[] | ((value: Value) => boolean)): Value | Value[] | undefined {
     if (keys === undefined) return Array.from(this.entries.values());
     if (typeof keys === "function")

package/src/ranger/client.ts

@@ -444,7 +444,7 @@ export class Client extends query.Retriever<
       table: composed,
       fetch: async (query) => [(await this.fetchSingle(query)).key],
       compose: ([record]) => record,
-      keyOf: (query) => (keyZ.safeParse(query).success ? query : null),
+      keyOf: (query) => (z.validate(keyZ, query) ? query : null),
       matches: (r, query) => r.key === query || r.name === query,
       single: true,
     });
@@ -576,9 +576,9 @@ export class Client extends query.Retriever<
   }
 
   async retrieve(params: Key | Name): Promise<Range>;
-  async retrieve(params: Key[] | Name[]): Promise<Range[]>;
-  async retrieve(params: CrudeTimeRange): Promise<Range[]>;
-  async retrieve(params: RetrieveRequest): Promise<Range[]>;
+  async retrieve(
+    params: Key[] | Name[] | CrudeTimeRange | RetrieveRequest,
+  ): Promise<Range[]>;
   async retrieve(params: RetrieveParams): Promise<Range | Range[]> {
     // The branches narrow params onto different base overloads.
     if (typeof params === "string") return await super.retrieve(params);
@@ -694,7 +694,7 @@ export class Client extends query.Retriever<
   private async fetchSingle(query: Key | Name): Promise<Range> {
     const cached = this.store.get(query);
     if (cached != null) return this.composeOne(cached);
-    if (keyZ.safeParse(query).success) {
+    if (z.validate(keyZ, query)) {
       const ranges = await this.store.retrieve([query]);
       checkForMultipleOrNoResults("Range", query, ranges, true);
       return this.composeOne(ranges[0]);

package/src/schematic/actions.ts

@@ -23,6 +23,9 @@ import {
   setNodePosition,
 } from "@/schematic/actions.gen";
 
+// Must match the pluto groupBox symbol's config variant.
+const GROUP_BOX_VARIANT = "groupBox";
+
 const handlers: Handlers = {
   create: (state, payload) => {
     Object.assign(state, payload.schematic);
@@ -83,16 +86,24 @@ const handlers: Handlers = {
       oldConfigRaw != null ? actions.snapshotDraft(oldConfigRaw) : undefined;
     state.nodes.splice(idx, 1);
     delete state.configs[payload.key];
-    return {
-      inverse: [
-        setNode(
-          oldConfig != null
-            ? { node: oldNode, config: oldConfig }
-            : { node: oldNode, config: undefined },
-        ),
-      ],
-      targets: [payload.key],
-    };
+    const inverse: Action[] = [
+      setNode(
+        oldConfig != null
+          ? { node: oldNode, config: oldConfig }
+          : { node: oldNode, config: undefined },
+      ),
+    ];
+    const targets = [payload.key];
+    for (const [key, config] of Object.entries(state.configs)) {
+      if (config?.variant !== GROUP_BOX_VARIANT) continue;
+      const members = config.members;
+      if (!Array.isArray(members) || !members.includes(payload.key)) continue;
+      const oldMembers = actions.snapshotDraft(members);
+      config.members = members.filter((m) => m !== payload.key);
+      inverse.push(setConfig({ key, config: { members: oldMembers } }));
+      targets.push(key);
+    }
+    return { inverse, targets };
   },
   addEdge: (state, payload) => {
     if (state.edges.some((e) => e.key === payload.edge.key))

package/src/status/status.ts

@@ -80,6 +80,96 @@ export const exceptionDetailsSchema = z
   })
   .and(record.unknownZ());
 
+// Bounds the clone check so it stays cheap even when errors are created in a tight
+// loop. An exhausted budget reports un-cloneable, which safely over-rebuilds.
+const CLONE_CHECK_BUDGET = 64;
+
+const isCloneableValue = (
+  v: unknown,
+  seen: Set<object>,
+  budget: { left: number },
+): boolean => {
+  if (--budget.left < 0) return false;
+  if (v == null) return true;
+  const t = typeof v;
+  if (t === "function" || t === "symbol") return false;
+  if (t !== "object") return true;
+  const o = v;
+  if (seen.has(o)) return true;
+  seen.add(o);
+  const values = (vals: unknown[]): boolean =>
+    vals.every((e) => isCloneableValue(e, seen, budget));
+  if (o instanceof Error)
+    return isCloneableValue(o.cause, seen, budget) && values(Object.values(o));
+  if (Array.isArray(o)) return values(o);
+  const proto = Object.getPrototypeOf(o);
+  if (proto === Object.prototype || proto === null) return values(Object.values(o));
+  if (o instanceof Date || o instanceof ArrayBuffer || ArrayBuffer.isView(o))
+    return true;
+  // Host objects (an Event, a DOM node) and exotic containers land here.
+  return false;
+};
+
+// Object.values can trip an enumerable getter that throws. Treat a throwing value
+// as not cloneable rather than throwing while already handling an error.
+const isCloneable = (v: unknown): boolean => {
+  try {
+    return isCloneableValue(v, new Set(), { left: CLONE_CHECK_BUDGET });
+  } catch {
+    return false;
+  }
+};
+
+// Returns a cloneable stand-in for an un-cloneable value.
+const cloneSafeValue = (v: unknown, depth: number): unknown => {
+  if (isCloneable(v)) return v;
+  if (v instanceof Error) return cloneSafeError(v, depth);
+  if (depth <= 0) return errors.fromUnknown(v).message;
+  try {
+    if (Array.isArray(v)) return v.map((e) => cloneSafeValue(e, depth - 1));
+    if (typeof v === "object" && v != null) {
+      const out: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(v))
+        if (typeof value !== "function" && typeof value !== "symbol")
+          out[key] = cloneSafeValue(value, depth - 1);
+      return out;
+    }
+  } catch {
+    // Tolerate throwing enumerable getters.
+  }
+  return errors.fromUnknown(v).message;
+};
+
+/**
+ * Returns err unchanged when it survives structured cloning. Otherwise rebuilds it
+ * with the same name, message, stack, and `type`, sanitizing un-cloneable fields and
+ * causes. Statuses cross the worker boundary, where an un-cloneable error kills the
+ * worker.
+ */
+const cloneSafeError = (err: Error, depth: number = 8): Error => {
+  if (isCloneable(err)) return err;
+  const safe = new Error(err.message);
+  safe.name = err.name;
+  safe.stack = err.stack;
+  const { type } = err as { type?: unknown };
+  if (typeof type === "string") (safe as { type?: string }).type = type;
+  try {
+    for (const [key, value] of Object.entries(err))
+      if (key !== "cause" && typeof value !== "function" && typeof value !== "symbol")
+        (safe as unknown as Record<string, unknown>)[key] = cloneSafeValue(
+          value,
+          depth - 1,
+        );
+  } catch {
+    // Tolerate throwing enumerable getters.
+  }
+  const { cause } = err;
+  if (cause !== undefined && depth > 0)
+    if (cause instanceof Error) safe.cause = cloneSafeError(cause, depth - 1);
+    else safe.cause = cloneSafeValue(cause, depth - 1);
+  return safe;
+};
+
 /** Flattens an error's cause chain into one readable line. */
 const causeChain = (err: Error): string | undefined => {
   const parts: string[] = [];
@@ -109,7 +199,7 @@ export const fromException = (
       message != null
         ? [err.message, detail].filter((part) => part != null).join(": ")
         : detail,
-    details: { stack: err.stack ?? "", error: err },
+    details: { stack: err.stack ?? "", error: cloneSafeError(err) },
   };
   // Probe the original (pre-coercion) value so a non-Error throwable with a custom
   // `toStatus()` method still contributes its status fields.