flugrekorder 1.1.0 → 1.2.0

package/dist/flugrekorder.js

@@ -28,16 +28,25 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 var flugrekorder_exports = {};
 __export(flugrekorder_exports, {
   create: () => create,
+  format: () => format,
   getAncestors: () => getAncestors,
   getOrigin: () => getOrigin,
   getPath: () => getPath,
   getProxyById: () => getProxyById,
   getTarget: () => getTarget,
-  isFlugrekorder: () => isFlugrekorder
+  isFlugrekorder: () => isFlugrekorder,
+  isProxiable: () => isProxiable
 });
 module.exports = __toCommonJS(flugrekorder_exports);
-var _byId, _byProxy, _byTarget, _generator;
-var Graph = class {
+
+// source/types.ts
+function isProxiable(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function");
+}
+
+// source/graph.ts
+var _index, _all, _byId, _byProxy, _byTarget, _generator;
+var _Graph = class _Graph {
   constructor(id) {
     __privateAdd(this, _byId, /* @__PURE__ */ new Map());
     __privateAdd(this, _byProxy, /* @__PURE__ */ new WeakMap());
@@ -46,9 +55,26 @@ var Graph = class {
     let counter = typeof id === "number" ? id : 0;
     __privateSet(this, _generator, typeof id === "function" ? id : () => `#${++counter}`);
   }
+  /** Returns the Graph that owns `pxy`, or `undefined` for non-proxies. */
+  static for(pxy) {
+    return __privateGet(_Graph, _index).get(pxy);
+  }
+  /** Returns `true` if `pxy` is a proxy created by this module. */
+  static isProxy(pxy) {
+    return __privateGet(_Graph, _all).has(pxy);
+  }
+  /** Marks `pxy` as a known proxy across all graphs (double-wrap guard). */
+  static track(pxy) {
+    __privateGet(_Graph, _all).add(pxy);
+  }
   nextId() {
     return __privateGet(this, _generator).call(this);
   }
+  /** Returns the underlying target if `value` is a proxy known to this graph, otherwise `value` unchanged. */
+  unwrap(value) {
+    if (!isProxiable(value)) return value;
+    return __privateGet(this, _byProxy).get(value)?.target ?? value;
+  }
   getByProxy(v) {
     return __privateGet(this, _byProxy).get(v);
   }
@@ -58,62 +84,89 @@ var Graph = class {
   getById(id) {
     return __privateGet(this, _byId).get(id);
   }
-  register(proxy, target, origin, id) {
-    const node = { id, proxy, target, origin };
+  register(proxy, target, origin2, id) {
+    const node = { id, proxy, target, origin: origin2 };
     __privateGet(this, _byId).set(id, node);
     __privateGet(this, _byProxy).set(proxy, node);
     __privateGet(this, _byTarget).set(target, node);
+    __privateGet(_Graph, _index).set(proxy, this);
     return node;
   }
 };
+_index = new WeakMap();
+_all = new WeakMap();
 _byId = new WeakMap();
 _byProxy = new WeakMap();
 _byTarget = new WeakMap();
 _generator = new WeakMap();
-var graphOf = /* @__PURE__ */ new WeakMap();
-var allProxies = /* @__PURE__ */ new WeakSet();
-var slotProtos = /* @__PURE__ */ new WeakMap();
-var bindCache = /* @__PURE__ */ new WeakMap();
-function isProxiable(value) {
-  return value !== null && (typeof value === "object" || typeof value === "function");
+__privateAdd(_Graph, _index, /* @__PURE__ */ new WeakMap());
+__privateAdd(_Graph, _all, /* @__PURE__ */ new WeakSet());
+var Graph = _Graph;
+
+// source/serialize.ts
+var defaults = {
+  depth: Infinity,
+  redactors: [],
+  truncate: Infinity
+};
+function redact(redactors, key, value, target) {
+  for (const redactor of redactors) {
+    const result = redactor(key, value, target);
+    if (result === false) continue;
+    return result === true ? "[redacted]" : result;
+  }
+  return false;
 }
-function serializeProxiable(v, graph, seen) {
-  const node = graph.getByProxy(v) ?? graph.getByTarget(v);
-  if (node !== void 0) return { $proxy: node.id };
-  if (Array.isArray(v))
-    return v.map((item) => serialize(item, graph, seen));
+function proxiable(v, graph, seen, serial, depth) {
+  const proxyNode = graph.getByProxy(v);
+  if (proxyNode !== void 0) return { $proxy: proxyNode.id };
+  const targetNode = graph.getByTarget(v);
+  if (targetNode !== void 0) return { $unwrap: { $proxy: targetNode.id } };
+  if (depth >= serial.depth) return "[\u2026]";
+  if (Array.isArray(v)) {
+    return v.map(
+      (item) => serialize(item, graph, seen, serial, depth + 1)
+    );
+  }
   if (seen.has(v)) return { $proxy: "?" };
   seen.add(v);
-  const result = Object.fromEntries(
-    Object.entries(v).map(([k, val]) => [
-      k,
-      serialize(val, graph, seen)
-    ])
-  );
+  const entries = [];
+  for (const [k, val] of Object.entries(v)) {
+    if (serial.redactors.length > 0) {
+      const decision = redact(serial.redactors, k, val, v);
+      if (decision === null) continue;
+      if (decision !== false) {
+        entries.push([k, decision]);
+        continue;
+      }
+    }
+    entries.push([k, serialize(val, graph, seen, serial, depth + 1)]);
+  }
   seen.delete(v);
-  return result;
+  return Object.fromEntries(entries);
 }
-var mappings = [
-  { match: /number|boolean|bigint/, map: (v) => v },
-  { match: /object|function/, map: serializeProxiable }
-];
-function serialize(v, graph, seen = /* @__PURE__ */ new Set()) {
+function serialize(v, graph, seen = /* @__PURE__ */ new Set(), serial = defaults, depth = 0) {
   if (v === null || v === void 0) return v;
-  const { map = String } = mappings.find(({ match }) => match.test(typeof v)) ?? {};
-  return map(v, graph, seen);
+  if (isProxiable(v)) return proxiable(v, graph, seen, serial, depth);
+  return typeof v === "string" ? v.length > serial.truncate ? `${v.slice(0, serial.truncate)}\u2026` : v : v;
 }
-function serializeOrigin(o) {
+function origin(o) {
   if (!o) return null;
   if ("key" in o)
     return { trap: o.trap, parent: o.parent, key: String(o.key) };
   return o;
 }
-var slotError = /incompatible receiver|this is not/i;
+
+// source/slots.ts
+var slotProtos = /* @__PURE__ */ new WeakMap();
+var bindCache = /* @__PURE__ */ new WeakMap();
+var slotError = /incompatible receiver|this is not|illegal invocation/i;
 function hasInternalSlots(target) {
   if (typeof target !== "object" || target === null) return false;
   const direct = Object.getPrototypeOf(target);
   if (!direct) return false;
-  if (slotProtos.has(direct)) return slotProtos.get(direct);
+  const cached = slotProtos.get(direct);
+  if (cached !== void 0) return cached;
   const probe = new Proxy(target, {
     set: () => true,
     defineProperty: () => true,
@@ -131,7 +184,8 @@ function hasInternalSlots(target) {
         try {
           fn.call(probe);
         } catch (e) {
-          if (e instanceof TypeError && slotError.test(String(e))) slots = true;
+          if (e instanceof TypeError && slotError.test(String(e)))
+            slots = true;
         }
         slotProtos.set(direct, slots);
         return slots;
@@ -143,207 +197,402 @@ function hasInternalSlots(target) {
   return false;
 }
 function boundMethod(target, key, fn) {
-  if (!bindCache.has(target)) bindCache.set(target, /* @__PURE__ */ new Map());
-  const cache = bindCache.get(target);
-  if (!cache.has(key)) cache.set(key, fn.bind(target));
-  return cache.get(key);
+  let cache = bindCache.get(target);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    bindCache.set(target, cache);
+  }
+  const existing = cache.get(key);
+  if (existing) return existing;
+  const bound = fn.bind(target);
+  cache.set(key, bound);
+  return bound;
+}
+
+// source/specs.ts
+var TypedArray = Object.getPrototypeOf(Int8Array);
+var ecmaBuiltins = [
+  Promise,
+  Map,
+  Set,
+  WeakMap,
+  WeakSet,
+  Date,
+  RegExp,
+  ArrayBuffer,
+  TypedArray,
+  DataView
+];
+function isECMABuiltin(v) {
+  return ecmaBuiltins.some((B) => v instanceof B);
+}
+function isUnsafeBinding(v) {
+  return isProxiable(v) && hasInternalSlots(v) && !isECMABuiltin(v);
 }
-var specs = {
-  get: {
-    // For targets with internal slots (Map, Set, WeakMap, WeakSet, Date …),
-    // use the real target as the Reflect.get receiver so that getter-based
-    // slot checks (e.g. Map.prototype.size) don't throw TypeError.
-    pre: ([target, key, receiver], _wrap, _known) => [
-      target,
-      key,
-      hasInternalSlots(target) ? target : receiver
-    ],
-    // For the same targets, bind method results to the real target before
-    // wrapping so that apply-level slot checks (e.g. Map.prototype.get)
-    // also pass.  The bind cache ensures proxy stability.
-    post: (result, [target, key], wrap) => {
-      if (key === "prototype") return result;
-      if (typeof result === "function" && hasInternalSlots(target)) {
-        return wrap(boundMethod(target, key, result));
+function makeSpecs(bind) {
+  return {
+    get: {
+      // For targets with internal slots (Map, Set, WeakMap, WeakSet, Date …)
+      // or when bind is true, use the real target as the Reflect.get
+      // receiver so that getter-based slot checks and #private field reads
+      // (e.g. `get value() { return this.#count; }`) don't throw TypeError.
+      pre: ([target, key, receiver], _wrap, _known) => [
+        target,
+        key,
+        hasInternalSlots(target) || bind ? target : receiver
+      ],
+      // For the same targets, bind method results to the real target before
+      // wrapping so that apply-level slot checks (e.g. Map.prototype.get)
+      // and #private field access inside methods also pass.
+      // The bind cache ensures proxy stability.
+      post: (result, [target, key], wrap) => {
+        if (key === "prototype") return result;
+        if (hasInternalSlots(target) || bind) {
+          if (typeof result === "function")
+            return wrap(
+              boundMethod(
+                target,
+                key,
+                result
+              )
+            );
+        }
+        if (isUnsafeBinding(result)) return result;
+        return wrap(result);
+      }
+    },
+    set: {
+      pre: ([target, key, value, receiver], wrap) => [
+        target,
+        key,
+        // Don't wrap when target has slots (Map/Set internals) or when the
+        // value is an unsafe C++ binding (TCP handles, etc.).
+        hasInternalSlots(target) || isUnsafeBinding(value) ? value : wrap(value),
+        receiver
+      ]
+    },
+    apply: {
+      // thisArg is wrapped normally (it's always a graph node).
+      // Call arguments are wrapped with known — only existing graph nodes
+      // get proxied; plain data passes through and is inlined by serialize().
+      pre: ([target, thisArg, callArgs], wrap, known) => [
+        target,
+        wrap(thisArg),
+        callArgs.map(known)
+      ],
+      post: (result, _args, wrap) => wrap(result)
+    },
+    construct: {
+      pre: ([target, callArgs, newTarget], wrap) => [
+        target,
+        callArgs.map(wrap),
+        newTarget
+      ],
+      post: (result, _args, wrap) => wrap(result)
+    },
+    defineProperty: {
+      pre: (args, wrap) => {
+        const [target, key, descriptor] = args;
+        const patch = {};
+        if (descriptor.value != null && !isUnsafeBinding(descriptor.value))
+          patch.value = wrap(descriptor.value);
+        if (typeof descriptor.get === "function")
+          patch.get = wrap(descriptor.get);
+        if (typeof descriptor.set === "function")
+          patch.set = wrap(descriptor.set);
+        return Object.keys(patch).length > 0 ? [target, key, { ...descriptor, ...patch }] : args;
+      }
+    },
+    getOwnPropertyDescriptor: {
+      post: (result, _args, wrap) => {
+        const desc = result;
+        if (!desc) return result;
+        const patch = {};
+        if (desc.value != null && !isUnsafeBinding(desc.value))
+          patch.value = wrap(desc.value);
+        if (typeof desc.get === "function")
+          patch.get = wrap(desc.get);
+        if (typeof desc.set === "function")
+          patch.set = wrap(desc.set);
+        return Object.keys(patch).length > 0 ? { ...desc, ...patch } : result;
       }
-      return wrap(result);
+    }
+  };
+}
+
+// source/errors.ts
+function isError(input) {
+  return input ? input instanceof Error : false;
+}
+function createErrorGuard(name, contains) {
+  const checks = [
+    isError,
+    (sub) => typeof sub === "object" && sub?.name === name
+  ];
+  if (contains instanceof RegExp) {
+    checks.push((v) => contains.test(String(v)));
+  }
+  return (input) => checks.every((predicate) => predicate(input));
+}
+
+// source/retry.ts
+function unwrap(graph, value) {
+  return graph?.unwrap(value) ?? value;
+}
+var isDataCloneDOMException = createErrorGuard("DataCloneError");
+var isTypeErrorPrivateMember = createErrorGuard("TypeError", /private member/i);
+var isTypeErrorIllegalInvocation = createErrorGuard("TypeError", /illegal invocation/i);
+var retryFlows = [
+  {
+    // Native methods (console.log, DOM APIs, http.Server) check the internal
+    // [[Receiver]] slot and throw "Illegal invocation" when called through a
+    // proxy. Unwrap the real target from the graph and retry as the receiver.
+    is: (trap, error) => trap === "apply" && isTypeErrorIllegalInvocation(error),
+    trap: "apply:native",
+    handle: (graph, fn, thisArg, argList) => {
+      const realThis = unwrap(graph, thisArg);
+      return {
+        args: [fn, realThis, argList],
+        result: Reflect.apply(fn, realThis, argList)
+      };
     }
   },
-  set: {
-    pre: ([target, key, value, receiver], wrap) => [
-      target,
-      key,
-      wrap(value),
-      receiver
-    ]
-  },
-  apply: {
-    // thisArg is wrapped normally (it's always a graph node).
-    // Call arguments are wrapped with known — only existing graph nodes
-    // get proxied; plain data passes through and is inlined by serialize().
-    pre: ([target, thisArg, callArgs], wrap, known) => [
-      target,
-      wrap(thisArg),
-      callArgs.map(known)
-    ],
-    post: (result, _args, wrap) => wrap(result)
-  },
-  construct: {
-    pre: ([target, callArgs, newTarget], wrap) => [
-      target,
-      callArgs.map(wrap),
-      newTarget
-    ],
-    post: (result, _args, wrap) => wrap(result)
+  {
+    // structuredClone and postMessage can't clone proxy objects — they throw a
+    // DataCloneError. Unwrap any proxy arguments to their real targets and retry.
+    is: (trap, error) => trap === "apply" && isDataCloneDOMException(error),
+    trap: "apply:structure",
+    handle: (graph, fn, thisArg, argList) => {
+      const unwrappedArgs = argList.map((arg) => unwrap(graph, arg));
+      return {
+        args: [fn, thisArg, unwrappedArgs],
+        result: Reflect.apply(fn, thisArg, unwrappedArgs)
+      };
+    }
   },
-  defineProperty: {
-    pre: (args, wrap) => {
-      const [target, key, descriptor] = args;
-      const patch = {};
-      if (descriptor.value != null) patch.value = wrap(descriptor.value);
-      if (typeof descriptor.get === "function")
-        patch.get = wrap(descriptor.get);
-      if (typeof descriptor.set === "function")
-        patch.set = wrap(descriptor.set);
-      return Object.keys(patch).length > 0 ? [target, key, { ...descriptor, ...patch }] : args;
+  {
+    // Private fields (#field) use brand checking — accessing #field on a proxy
+    // (rather than the original instance) throws "Cannot read private member".
+    // Unwrap the real instance from the graph and use it as the receiver.
+    is: (trap, error, bind) => bind !== false && trap === "apply" && isTypeErrorPrivateMember(error),
+    trap: "apply:private",
+    handle: (graph, fn, thisArg, argList) => {
+      const realThis = unwrap(graph, thisArg);
+      return {
+        args: [fn, realThis, argList],
+        result: Reflect.apply(fn, realThis, argList)
+      };
     }
   },
-  getOwnPropertyDescriptor: {
-    post: (result, _args, wrap) => {
-      const desc = result;
-      if (!desc) return result;
-      const patch = {};
-      if (desc.value != null) patch.value = wrap(desc.value);
-      if (typeof desc.get === "function")
-        patch.get = wrap(desc.get);
-      if (typeof desc.set === "function")
-        patch.set = wrap(desc.set);
-      return Object.keys(patch).length > 0 ? { ...desc, ...patch } : result;
+  {
+    // A getter that reads a #private field hits the same brand check, but the
+    // apply retry doesn't apply here. Re-invoke Reflect.get with the real target
+    // as its own receiver so the brand check passes.
+    is: (trap, error, bind) => bind !== false && trap === "get" && isTypeErrorPrivateMember(error),
+    handle: (_graph, target, propertyKey) => ({
+      result: Reflect.get(target, propertyKey, target)
+    })
+  }
+];
+
+// source/inspection.ts
+function getTarget(pxy) {
+  return Graph.for(pxy)?.getByProxy(pxy)?.target ?? null;
+}
+function getProxyById(id, pxy) {
+  return Graph.for(pxy)?.getById(id)?.proxy;
+}
+function getOrigin(pxy) {
+  return Graph.for(pxy)?.getByProxy(pxy)?.origin ?? null;
+}
+function getAncestors(pxy) {
+  const graph = Graph.for(pxy);
+  if (!graph) return [];
+  const result = [];
+  let node = graph.getByProxy(pxy);
+  while (node) {
+    result.unshift({ proxy: node.proxy, origin: node.origin });
+    if (!node.origin) break;
+    const parentId = "parent" in node.origin ? node.origin.parent : node.origin.source;
+    node = graph.getById(parentId);
+  }
+  return result;
+}
+function getPath(pxy) {
+  const ancestors = getAncestors(pxy);
+  const parts = [];
+  for (const { origin: o } of ancestors) {
+    if (!o) continue;
+    if ("key" in o) {
+      parts.push(String(o.key));
+    } else {
+      if (parts.length > 0) {
+        parts[parts.length - 1] += "()";
+      } else {
+        parts.push("()");
+      }
     }
   }
-};
-function makeProxy(target, graph, config, origin) {
-  if (allProxies.has(target)) return target;
+  return parts.join(".");
+}
+
+// source/format.ts
+function resolve(id, proxy) {
+  if (!proxy) return id;
+  const p = getProxyById(id, proxy);
+  return p !== void 0 ? getPath(p) : id;
+}
+function display(v, proxy, limit = 80) {
+  if (v === null || v === void 0) return String(v);
+  if (typeof v !== "object") return String(v);
+  if (!Array.isArray(v) && "$proxy" in v)
+    return resolve(v.$proxy, proxy);
+  if (!Array.isArray(v) && "$unwrap" in v)
+    return `\u2193${resolve(v.$unwrap.$proxy, proxy)}`;
+  const raw = Array.isArray(v) ? `[${v.map((i) => display(i, proxy)).join(", ")}]` : JSON.stringify(v);
+  return raw.length > limit ? `${raw.slice(0, limit)}\u2026` : raw;
+}
+function format(rekording, proxy) {
+  const { id, trap, origin: origin2, args, result } = rekording;
+  if (origin2 && "parent" in origin2) {
+    const parent = resolve(origin2.parent, proxy);
+    const path = parent ? `${parent}.${origin2.key}` : String(origin2.key);
+    if (trap === "set") return `${path} = ${display(args[2], proxy)}`;
+    if (trap === "get") return `${path} \u2192 ${display(result, proxy)}`;
+    return `${trap} ${path}`;
+  }
+  if (origin2 && "source" in origin2) {
+    const path = resolve(origin2.source, proxy);
+    const callArgs = (Array.isArray(trap === "construct" ? args[1] : args[2]) ? trap === "construct" ? args[1] : args[2] : []).map((a) => display(a, proxy)).join(", ");
+    if (/^apply(:|$)/.test(trap))
+      return `${path}(${callArgs})`;
+    if (trap === "construct" || trap === "construct:native")
+      return `new ${path}(${callArgs})`;
+  }
+  return `${trap} on ${id}`;
+}
+
+// source/flugrekorder.ts
+function makeProxy(target, graph, config, origin2) {
+  if (Graph.isProxy(target)) return target;
   const existing = graph.getByTarget(target);
   if (existing) return existing.proxy;
   if (target instanceof Promise) {
     const chained = target.then(
-      (value) => isProxiable(value) ? makeProxy(value, graph, config, origin) : value
+      (value) => isProxiable(value) ? makeProxy(value, graph, config, origin2) : value
     );
     const id = graph.nextId();
-    graph.register(chained, target, origin, id);
-    graphOf.set(chained, graph);
+    graph.register(chained, target, origin2, id);
     return chained;
   }
   const proxyId = graph.nextId();
-  let pxy;
   const traps = Object.getOwnPropertyNames(Reflect).filter((trap) => config.only === null || config.only.has(trap));
   const handler = Object.fromEntries(
     traps.map((trap) => [
       trap,
       (...rawArgs) => {
-        const selfId = graph.getByProxy(pxy).id;
-        const childOrigin = /get|set|defineProperty|getOwnPropertyDescriptor/.test(trap) ? {
+        const selfId = graph.getByTarget(target).id;
+        let childOrigin = /get|set|defineProperty|getOwnPropertyDescriptor/.test(trap) ? {
           trap,
           parent: selfId,
           key: rawArgs[1]
         } : /apply|construct/.test(trap) ? { trap, source: selfId } : null;
         const wrap = (v) => {
-          if (!isProxiable(v) || allProxies.has(v))
+          if (!isProxiable(v) || Graph.isProxy(v))
             return v;
           if (!config.recursive) return v;
           return makeProxy(v, graph, config, childOrigin);
         };
         const known = (v) => {
           if (!isProxiable(v)) return v;
-          if (allProxies.has(v)) return v;
+          if (Graph.isProxy(v)) return v;
           const existing2 = graph.getByTarget(v);
           if (existing2) return existing2.proxy;
           return v;
         };
-        const spec = specs[trap] ?? {};
-        const args = spec.pre ? spec.pre(rawArgs, wrap, known) : rawArgs;
-        const result = Reflect[trap](...args);
-        const output = spec.post ? spec.post(result, args, wrap) : result;
-        config.write({
+        const spec = config.specs[trap] ?? {};
+        const preArgs = spec.pre ? spec.pre(rawArgs, wrap, known) : rawArgs;
+        let effectiveTrap = trap;
+        let effectiveArgs = preArgs;
+        let result;
+        try {
+          result = Reflect[trap](...preArgs);
+        } catch (e) {
+          const flow = retryFlows.find(
+            ({ is }) => is(trap, e, config.bind)
+          );
+          if (flow) {
+            const invoke = flow.handle;
+            const output2 = invoke(graph, ...preArgs);
+            if (flow.trap) {
+              effectiveTrap = flow.trap;
+              childOrigin = {
+                trap: flow.trap,
+                source: selfId
+              };
+            }
+            if (output2?.args) effectiveArgs = output2.args;
+            result = output2.result;
+          } else {
+            throw e;
+          }
+        }
+        const output = spec.post ? spec.post(result, effectiveArgs, wrap) : result;
+        const rekording = {
           id: graph.nextId(),
-          trap,
-          origin: serializeOrigin(childOrigin),
-          args: args.map((arg) => serialize(arg, graph)),
-          result: serialize(output, graph)
-        });
+          trap: effectiveTrap,
+          origin: origin(childOrigin),
+          args: effectiveArgs.map(
+            (arg) => serialize(arg, graph, /* @__PURE__ */ new Set(), config.serial)
+          ),
+          result: serialize(output, graph, /* @__PURE__ */ new Set(), config.serial),
+          timestamp: Date.now()
+        };
+        if (!config.filter || config.filter(rekording))
+          config.write(rekording);
         return output;
       }
     ])
   );
-  pxy = new Proxy(target, handler);
-  graph.register(pxy, target, origin, proxyId);
-  graphOf.set(pxy, graph);
-  allProxies.add(pxy);
+  const pxy = new Proxy(target, handler);
+  graph.register(pxy, target, origin2, proxyId);
+  Graph.track(pxy);
   return pxy;
 }
 function create(target, options) {
-  const { stream, callback } = options;
-  const write = stream ? (r) => stream.write(`${JSON.stringify(r)}
-`) : (
-    // biome-ignore lint/style/noNonNullAssertion: CreateOptions guarantees stream or callback is set — TypeScript cannot express this mutual exclusion
-    callback
-  );
+  const write = "stream" in options ? (r) => options.stream.write(`${JSON.stringify(r)}
+`) : options.callback;
   const recursive = options.recursive !== false;
   const only = options.only ? new Set(options.only) : null;
+  const filter = options.filter ?? null;
+  const { redact: redact2 } = options;
+  const serial = {
+    depth: options.depth ?? Infinity,
+    redactors: redact2 ? Array.isArray(redact2) ? redact2 : [redact2] : [],
+    truncate: options.truncate ?? Infinity
+  };
   const graph = new Graph(options.id ?? 0);
-  return makeProxy(target, graph, { write, recursive, only }, null);
+  const specs = makeSpecs(options.bind);
+  return makeProxy(
+    target,
+    graph,
+    { write, recursive, only, filter, serial, specs, bind: options.bind },
+    null
+  );
 }
 function isFlugrekorder(value) {
-  return isProxiable(value) && allProxies.has(value);
-}
-function getTarget(pxy) {
-  return graphOf.get(pxy)?.getByProxy(pxy)?.target ?? null;
-}
-function getProxyById(id, pxy) {
-  return graphOf.get(pxy)?.getById(id)?.proxy;
-}
-function getOrigin(pxy) {
-  return graphOf.get(pxy)?.getByProxy(pxy)?.origin ?? null;
-}
-function getAncestors(pxy) {
-  const graph = graphOf.get(pxy);
-  if (!graph) return [];
-  const result = [];
-  let node = graph.getByProxy(pxy);
-  while (node) {
-    result.unshift({ proxy: node.proxy, origin: node.origin });
-    if (!node.origin) break;
-    const parentId = "parent" in node.origin ? node.origin.parent : node.origin.source;
-    node = graph.getById(parentId);
-  }
-  return result;
-}
-function getPath(pxy) {
-  const ancestors = getAncestors(pxy);
-  const parts = [];
-  for (const { origin: o } of ancestors) {
-    if (!o) continue;
-    if ("key" in o) {
-      parts.push(String(o.key));
-    } else {
-      if (parts.length > 0) {
-        parts[parts.length - 1] += "()";
-      } else {
-        parts.push("()");
-      }
-    }
-  }
-  return parts.join(".");
+  return isProxiable(value) && Graph.isProxy(value);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   create,
+  format,
   getAncestors,
   getOrigin,
   getPath,
   getProxyById,
   getTarget,
-  isFlugrekorder
+  isFlugrekorder,
+  isProxiable
 });
 //# sourceMappingURL=flugrekorder.js.map