@kirill.konshin/utils 0.0.14 → 0.0.15

package/dist/react/keyboard.js

@@ -0,0 +1,38 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useState, useMemo, useContext, useEffect } from "react";
+const isCtrlOrMeta = (e) => e.metaKey || e.ctrlKey;
+const EVENT = "keydown";
+const HotkeysContext = createContext(null);
+const HotkeysProvider = ({ children }) => {
+  const [enabled, setEnabled] = useState(true);
+  const control = useMemo(() => ({ enabled, setEnabled }), [enabled, setEnabled]);
+  return /* @__PURE__ */ jsx(HotkeysContext.Provider, { value: control, children });
+};
+const useHotkeys = (hotkeys) => {
+  const { enabled } = useContext(HotkeysContext);
+  useEffect(() => {
+    if (typeof document === "undefined" || !enabled) {
+      return;
+    }
+    const listeners = (e) => {
+      if (!isCtrlOrMeta(e)) return;
+      for (const [code, callback] of Object.entries(hotkeys)) {
+        if (e.code === code) {
+          callback(e);
+          return;
+        }
+      }
+    };
+    window.addEventListener(EVENT, listeners, true);
+    return () => {
+      window.removeEventListener(EVENT, listeners);
+    };
+  }, [hotkeys, enabled]);
+};
+export {
+  HotkeysContext,
+  HotkeysProvider,
+  useHotkeys
+};
+//# sourceMappingURL=keyboard.js.map

package/dist/react/keyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.js","sources":["../../src/react/keyboard.tsx"],"sourcesContent":["'use client';\n\nimport { useEffect, createContext, useMemo, useState, Dispatch, SetStateAction, useContext } from 'react';\n\nconst isCtrlOrMeta = (e: KeyboardEvent) => e.metaKey || e.ctrlKey;\n\nconst EVENT = 'keydown';\n\nexport type Hotkeys = Record<KeyboardEvent['code'], (e: KeyboardEvent) => void>;\n\nexport const HotkeysContext = createContext<{\n    enabled: boolean;\n    setEnabled: Dispatch<SetStateAction<boolean>>;\n}>(null as never);\n\nexport const HotkeysProvider = ({ children }) => {\n    const [enabled, setEnabled] = useState(true);\n\n    const control = useMemo(() => ({ enabled, setEnabled }), [enabled, setEnabled]);\n\n    return <HotkeysContext.Provider value={control}>{children}</HotkeysContext.Provider>;\n};\n\nexport const useHotkeys = (hotkeys: Hotkeys) => {\n    const { enabled } = useContext(HotkeysContext);\n\n    useEffect(() => {\n        if (typeof document === 'undefined' || !enabled) {\n            return;\n        }\n\n        const listeners = (e: KeyboardEvent) => {\n            if (!isCtrlOrMeta(e)) return;\n\n            for (const [code, callback] of Object.entries(hotkeys)) {\n                if (e.code === code) {\n                    callback(e);\n                    return;\n                }\n            }\n        };\n\n        window.addEventListener(EVENT, listeners, true);\n\n        return () => {\n            window.removeEventListener(EVENT, listeners);\n        };\n    }, [hotkeys, enabled]);\n};\n"],"names":[],"mappings":";;;AAIA,MAAM,eAAe,CAAC,MAAqB,EAAE,WAAW,EAAE;AAE1D,MAAM,QAAQ;AAID,MAAA,iBAAiB,cAG3B,IAAa;AAET,MAAM,kBAAkB,CAAC,EAAE,eAAe;AAC7C,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,IAAI;AAErC,QAAA,UAAU,QAAQ,OAAO,EAAE,SAAS,eAAe,CAAC,SAAS,UAAU,CAAC;AAE9E,6BAAQ,eAAe,UAAf,EAAwB,OAAO,SAAU,UAAS;AAC9D;AAEa,MAAA,aAAa,CAAC,YAAqB;AAC5C,QAAM,EAAE,QAAA,IAAY,WAAW,cAAc;AAE7C,YAAU,MAAM;AACZ,QAAI,OAAO,aAAa,eAAe,CAAC,SAAS;AAC7C;AAAA,IAAA;AAGE,UAAA,YAAY,CAAC,MAAqB;AAChC,UAAA,CAAC,aAAa,CAAC,EAAG;AAEtB,iBAAW,CAAC,MAAM,QAAQ,KAAK,OAAO,QAAQ,OAAO,GAAG;AAChD,YAAA,EAAE,SAAS,MAAM;AACjB,mBAAS,CAAC;AACV;AAAA,QAAA;AAAA,MACJ;AAAA,IAER;AAEO,WAAA,iBAAiB,OAAO,WAAW,IAAI;AAE9C,WAAO,MAAM;AACF,aAAA,oBAAoB,OAAO,SAAS;AAAA,IAC/C;AAAA,EAAA,GACD,CAAC,SAAS,OAAO,CAAC;AACzB;"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kirill.konshin/utils",
   "description": "Utilities",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "type": "module",
   "scripts": {
     "----- BUILD -----": "",
@@ -24,6 +24,7 @@
     "expo-file-system": "^18.0.7",
     "expo-sharing": "^13.0.1",
     "expo-updates": "^0.26.13",
+    "file-saver": "^2.0.5",
     "many-keys-map": "^2.0.1",
     "psd": "^3.4.0",
     "react-hook-form": "^7.54.2",
@@ -43,8 +44,10 @@
     "@storybook/react": "^8.5.2",
     "@storybook/react-vite": "^8.5.2",
     "@storybook/test": "^8.5.2",
+    "@types/file-saver": "^2",
     "@types/psd": "^3.4.3",
     "@vitest/coverage-v8": "^3.0.4",
+    "@vitest/web-worker": "^3.0.5",
     "bootstrap": "^5.3.3",
     "bootstrap-icons": "^1.11.3",
     "create-ts-index": "^1.14.0",
@@ -179,4 +182,4 @@
   "main": "./dist/core/index.js",
   "module": "./dist/core/index.js",
   "types": "./dist/core/index.d.ts"
-}
+}

package/src/bootstrap/controls.stories.tsx

@@ -7,7 +7,7 @@ import { Select, Control, Range, Checkbox } from './controls';
 const defaultOptions = { num: 1, bool: false, select: 'bar' };
 
 // More on how to set up stories at: https://storybook.js.org/docs/writing-stories#default-export
-const meta = {
+const meta: Meta<typeof Control> = {
     title: 'Bootstrap / Controls',
     parameters: {
         layout: 'centered',
@@ -32,7 +32,7 @@ const meta = {
 
         return <div style={{ width: '300px' }}>{cloneElement(children as any, { ...safeArgs, ...controlProps })}</div>;
     },
-} satisfies Meta<typeof Control>;
+};
 
 export default meta;
 

package/src/bootstrap/controls.tsx

@@ -4,7 +4,7 @@ const lcFirst = (str) => str[0].toLowerCase() + str.substring(1, str.length);
 
 const toProperty = (str) => lcFirst(str).split(' ').join('');
 
-interface ControlProps {
+export interface ControlProps {
     value?: any;
     setValue?: (v: any) => void;
     defaultValue?: any;
@@ -22,9 +22,9 @@ interface ControlProps {
     hideValue?: boolean;
 }
 
-type LabelProps = Pick<ControlProps, 'name' | 'value' | 'defaultValue'> & { reset: () => void };
+export type LabelProps = Pick<ControlProps, 'name' | 'value' | 'defaultValue'> & { reset: () => void };
 
-const Label = memo<LabelProps>(function Label({ name, reset, value, defaultValue }) {
+export const Label = memo<LabelProps>(function Label({ name, reset, value, defaultValue }) {
     return (
         <label className="flex-grow-1 mb-0 d-flex align-items-center justify-content-start gap-2">
             {name}

package/src/bootstrap/error.stories.tsx

@@ -4,7 +4,7 @@ import { fn } from '@storybook/test';
 import { ErrorAlert } from './error';
 
 // More on how to set up stories at: https://storybook.js.org/docs/writing-stories#default-export
-const meta = {
+const meta: Meta<typeof ErrorAlert> = {
     title: 'Bootstrap / ErrorAlert',
     component: ErrorAlert,
     parameters: {
@@ -16,7 +16,7 @@ const meta = {
         children: { control: 'text' },
     },
     args: { onRetry: fn() },
-} satisfies Meta<typeof ErrorAlert>;
+};
 
 export default meta;
 type Story = StoryObj<typeof meta>;
@@ -29,6 +29,6 @@ export const String: Story = {
 
 export const ErrorObject: Story = {
     args: {
-        children: new Error('An error occurred'),
+        children: new Error('An error occurred') as any,
     },
 };

package/src/bootstrap/field.stories.tsx

@@ -6,7 +6,7 @@ import { FieldGroup } from './field';
 import { FormControl } from 'react-bootstrap';
 
 // More on how to set up stories at: https://storybook.js.org/docs/writing-stories#default-export
-const meta = {
+const meta: Meta<typeof FieldGroup> = {
     title: 'Bootstrap / FieldGroup',
     component: FieldGroup,
     parameters: {
@@ -19,7 +19,7 @@ const meta = {
         horizontal: { control: 'check' },
     },
     args: { onClick: fn() },
-} satisfies Meta<typeof FieldGroup>;
+};
 
 export default meta;
 

package/src/bootstrap/globalLoading.stories.tsx

@@ -2,7 +2,7 @@ import type { Meta, StoryObj } from '@storybook/react';
 
 import { GlobalLoading } from './globalLoading';
 
-const meta = {
+const meta: Meta<typeof GlobalLoading> = {
     title: 'Bootstrap / GlobalLoading',
     component: GlobalLoading,
     parameters: {
@@ -12,7 +12,7 @@ const meta = {
     argTypes: {
         loading: { control: 'check' },
     },
-} satisfies Meta<typeof GlobalLoading>;
+};
 
 export default meta;
 

package/src/bootstrap/loading.stories.tsx

@@ -2,7 +2,7 @@ import type { Meta, StoryObj } from '@storybook/react';
 
 import { Loading } from './loading';
 
-const meta = {
+const meta: Meta<typeof Loading> = {
     title: 'Bootstrap / Loading',
     component: Loading,
     parameters: {
@@ -14,7 +14,7 @@ const meta = {
         show: { control: 'check' },
         size: { control: 'select', options: ['sm', 'md'] },
     },
-} satisfies Meta<typeof Loading>;
+};
 
 export default meta;
 

package/src/bootstrap/screen.stories.tsx

@@ -45,7 +45,7 @@ const lorem = (
     </>
 );
 
-const meta = {
+const meta: Meta<typeof Screen> = {
     title: 'Bootstrap / Screen',
     component: Screen,
     parameters: {
@@ -75,7 +75,7 @@ const meta = {
         ),
         backCb: fn(),
     },
-} satisfies Meta<typeof Screen>;
+};
 
 export default meta;
 

package/src/bootstrap/toaster.stories.tsx

@@ -4,7 +4,7 @@ import { fn } from '@storybook/test';
 import { Toaster } from './toaster';
 
 // More on how to set up stories at: https://storybook.js.org/docs/writing-stories#default-export
-const meta = {
+const meta: Meta<typeof Toaster> = {
     title: 'Bootstrap / Toaster',
     component: Toaster,
     parameters: {
@@ -13,7 +13,7 @@ const meta = {
     tags: ['autodocs'],
     argTypes: {},
     args: { onClick: fn() },
-} satisfies Meta<typeof Toaster>;
+};
 
 export default meta;
 

package/src/bootstrap/useModal.stories.tsx

@@ -1,10 +1,10 @@
 import React, { FC } from 'react';
 import type { Meta, StoryObj } from '@storybook/react';
 import { useModal, UseModalProps } from './useModal';
-import { Button, ButtonGroup } from 'react-bootstrap';
+import { Button } from 'react-bootstrap';
 
 // More on how to set up stories at: https://storybook.js.org/docs/writing-stories#default-export
-const meta = {
+const meta: Meta<FC<UseModalProps>> = {
     title: 'Bootstrap / useModal',
     parameters: {
         layout: 'centered',
@@ -34,7 +34,7 @@ const meta = {
         );
     },
     // args: { onSubmit: (e) => e.preventDefault() },
-} satisfies Meta<FC<UseModalProps>>;
+};
 
 export default meta;
 

package/src/core/README.md

@@ -0,0 +1,91 @@
+# WRPC
+
+TODO
+
+- [ ] Add to readme https://stackoverflow.com/questions/77727664/how-to-get-returned-value-from-async-generator-when-using-for-await
+- [ ] Value passed to next are ignored https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncGenerator/next#sending_values_to_the_generator
+
+```mermaid
+sequenceDiagram
+    box Main
+    participant Code
+    participant Caller
+    end
+    box Worker
+    participant Worker
+    participant Resolver
+    end
+
+    %% autonumber
+
+    Code->>Caller: caller.generator(payload)
+
+    Caller-->>Code: iterator & promise
+
+    Code->>Code: Start main CONSUMER loop
+
+    Code->>Caller: iterator[Symbol]()
+
+    Caller->>Caller: Start replica GENERATOR loop
+
+    Code->>Caller: iterator.next()
+
+    Caller->>Worker: postMessage(payload)
+
+    Worker->>Resolver: resolver(payload)
+
+    Resolver-->>Worker: iterator
+
+    Worker->>Worker: Start replica CONSUMER loop
+
+    Worker->>Resolver: iterator[Symbol]()
+
+    Resolver->>Resolver: Start GENERATOR loop
+
+    rect rgb(232, 244, 248)
+
+        loop Synchronized iteration
+            Worker->>+Resolver: iterator.next(payload)
+
+            Resolver-->>-Worker: yield value
+
+            Worker-->>Caller: postMessage(value, done=false)
+
+            Note over Worker: Wait for ACK or ABORT
+
+            Caller-->>Code: yield value
+
+            Code->>Caller: iterator.next(nextPayload)
+
+            Caller->>Worker: postMessage(ack, nextPayload)
+        end
+
+    end
+
+    break Break or AbortSignal (maybe)
+        Code-->>Code: Loop exits
+        Code->>Caller: signal.abort()
+
+        Caller-->>Caller: Loop exits
+
+        Caller->>Worker: postMessage(abort)
+
+        Worker-->>Worker: Loop exits via Break
+
+        Resolver-->>Resolver: Loop exits
+    end
+
+    opt Occurs on Error
+        Resolver-->>Worker: throw Error
+
+        Worker-->>Caller: postMessage(error, done=true)
+
+        Caller-->>Code: throw Error
+    end
+
+    Resolver-->>Worker: return value
+
+    Worker-->>Caller: postMessage(value, done=true)
+
+    Caller-->>Code: return value
+```

package/src/core/cache.ts

@@ -64,6 +64,7 @@ export function memo<Key extends any[], Val, SerializedKey extends any[] = Key>(
 ) {
     const map = new ManyKeysMap<SerializedKey, Val>();
 
+    //TODO Extend ManyKeysMap
     const clear = (...condition: Key | any[]) => {
         if (!condition?.length) {
             map.forEach((value, serializedKey) => {
@@ -114,17 +115,12 @@ export function memo<Key extends any[], Val, SerializedKey extends any[] = Key>(
  *
  * This makes possible to implement various one-off and subsequent transformations.
  *
- * 1. `write`: Before writing to cache, called only once if cache is present and valid
- * 2. `read`: After it's read from cache, always called if cache is valid
- * TODO Better names: once, folloing
- * TODO Better names: memoize, recover
- * TODO Better names: writeTransformer, readTransformer
- * TODO Better names: writeModifier, readModifier
- * TODO Better names: write, read
+ * 1. `write`: Transform value BEFORE writing to cache, called only once if cache IS NOT present or IS NOT valid
+ * 2. `read`: Transform value AFTER it's read from cache, always called if cache IS valid, keep in mind this transform is applied on top of BEFORE
  *
  * Both should return same type or null.
  *
- * If newValue is null, old is returned, and no cache is set.
+ * If `newValue` is null, old is returned, and no cache is set.
  *
  * ```ts
  * class InputCache extends TypedCache<string, ImageBitmap> {
@@ -186,7 +182,7 @@ export function memo<Key extends any[], Val, SerializedKey extends any[] = Key>(
  */
 export abstract class TransformerMap<Key, Val = Key> extends Map<Key, Val> {
     constructor(protected readonly name: string) {
-        console.warn('CREATE cache', name);
+        // console.warn('CREATE cache', name);
         super();
     }
 
@@ -199,13 +195,17 @@ export abstract class TransformerMap<Key, Val = Key> extends Map<Key, Val> {
     }
 
     delete(key: Key) {
-        const has = this.has(key);
-        if (has) this.dispose(this.get(key) as Val, key);
+        const val = this.get(key);
+        const has = typeof val !== 'undefined';
+        if (has) this.dispose(val, key);
         super.delete(key);
         return has;
     }
 
-    // do something with the value and key before removing it
+    /**
+     * Do something with the value and key before removing it from cache
+     * For example, close a file or a bitmap
+     */
     protected dispose(value: Val, key: Key) {}
 
     clear() {

package/src/core/files.ts

@@ -0,0 +1,24 @@
+import { saveAs } from 'file-saver';
+
+export const downloadFile = async (filename, text, type = 'application/json') => {
+    //FIXME https://github.com/eligrey/FileSaver.js/issues/731
+    saveAs(new Blob([text], { type }), filename);
+};
+
+export const openFile = (): Promise<string> =>
+    new Promise((res, rej) => {
+        const input = document.createElement('input');
+        input.type = 'file';
+        input.addEventListener('change', function readFile(e) {
+            input.removeEventListener('change', readFile);
+            // @ts-expect-error file is always there
+            const [file] = e.target.files;
+            if (!file) return;
+            const reader = new FileReader();
+            reader.onload = (e) => res(e.target?.result as string);
+            reader.onerror = rej;
+            reader.onabort = rej;
+            reader.readAsText(file);
+        });
+        input.click();
+    });

package/src/core/index.ts

@@ -1,5 +1,9 @@
 export * from './cache';
 export * from './errors';
+export * from './files';
+export * from './ls';
 export * from './measure';
 export * from './mutex';
 export * from './worker';
+export * from './workerUtils';
+export * from './wrpc';

package/src/core/ls.ts

@@ -0,0 +1,11 @@
+export function getStorage(pref: string) {
+    const prefix = (key) => `${pref}-${key}`;
+
+    const ls = (typeof window !== 'undefined' ? localStorage : null) as Storage;
+
+    const read = (key: string) => JSON.parse(ls?.getItem(prefix(key)) || 'null');
+    const write = (key: string, value: any) => ls?.setItem(prefix(key), JSON.stringify(value));
+    const remove = (key: string) => ls?.removeItem(prefix(key));
+
+    return { read, write, remove };
+}

package/src/core/worker.test.ts

@@ -0,0 +1,197 @@
+import { expect, describe, test, vi } from 'vitest';
+import { RespondersBase, WorkerDialog } from './worker';
+import EventEmitter from 'node:events';
+
+// Prepare
+
+//TODO @vitest/web-worker can ve used, coverage is collected, but this gives more direct access to worker internals
+// class WorkerPeer extends EventEmitter implements WorkerLike {
+class WorkerPeer extends EventEmitter {
+    peer: WorkerPeer;
+
+    setPeer(peer: WorkerPeer) {
+        this.peer = peer;
+    }
+
+    postMessage(data: any) {
+        this.peer?.emit('message', { data });
+    }
+
+    addEventListener(event: string, listener: (e: any) => void, options) {
+        this[options['once'] ? 'once' : 'on'](event, listener);
+        options?.signal?.addEventListener('abort', () => this.off(event, listener));
+    }
+
+    removeEventListener(event: string, listener: (e: any) => void) {
+        this.off(event, listener);
+    }
+}
+
+class Responders extends RespondersBase<Responders> {
+    lastContext: any; // for testing purposes
+
+    test = this.create(
+        'test',
+        async (
+            { n, abort = false, buf }: { n: number; abort?: boolean; buf?: ArrayBuffer }, // should have all possible combinations for strong typing
+            ctx,
+        ) => {
+            this.lastContext = ctx;
+
+            const res: number[] = [];
+
+            let aborted = false;
+            let progress = 0;
+
+            ctx.listen(({ abort }) => {
+                if (abort) aborted = true;
+            });
+
+            for (const i of Array(n).keys()) {
+                if (aborted) break;
+                progress = (i + 1) / n;
+                ctx.send({ progress });
+                res.push(i);
+            }
+
+            return { res, progress, aborted };
+        },
+    );
+
+    error = this.create(
+        'error',
+        async (
+            _, // should have all possible combinations for strong typing
+            ctx,
+        ) => {
+            this.lastContext = ctx;
+            throw new Error('Test');
+        },
+    );
+}
+
+const createWorker = () => {
+    const mainWorker = new WorkerPeer();
+    const mainDialog = new WorkerDialog(
+        mainWorker as never as Worker,
+        {} as WorkerDialog<Responders>['responders'],
+        'Main',
+    );
+
+    const worker = new WorkerPeer();
+    const workerDialog = new WorkerDialog(worker as never as Worker, new Responders(), 'Worker');
+
+    mainWorker.setPeer(worker);
+    worker.setPeer(mainWorker);
+
+    return { mainWorker, mainDialog, worker, workerDialog };
+};
+
+// Tests
+
+describe('Worker', async () => {
+    test('simple', async () => {
+        const { mainDialog, workerDialog } = createWorker();
+
+        const l = vi.fn();
+        let mctx;
+
+        const result = await mainDialog.withMessage('test').fetch({ n: 3, buf: new ArrayBuffer() }, (ctx) => {
+            mctx = ctx;
+            ctx.listen(l);
+        });
+
+        expect(l).toBeCalledTimes(4); // 3x progress, last
+        expect(result).toStrictEqual({ res: [0, 1, 2], progress: 1, aborted: false });
+
+        expect(mainDialog.contexts.size).toBe(0);
+        expect(mctx.debugInfo.closed).toBe(true);
+
+        expect(workerDialog.contexts.size).toBe(2);
+        expect(workerDialog.contexts.values().next().value.debugInfo).toStrictEqual({
+            id: '*',
+            parentId: undefined,
+            message: 'test',
+            closed: false,
+            type: 'response',
+            listeners: 1,
+        });
+        expect(workerDialog.responders.lastContext.debugInfo).toStrictEqual({
+            id: '1',
+            parentId: '*',
+            message: 'test',
+            closed: true,
+            type: 'response',
+            listeners: 0,
+        });
+    });
+
+    test('abort', async () => {
+        const { mainDialog } = createWorker();
+
+        const result = await mainDialog.withMessage('test').fetch({ n: 3 }, (ctx) => {
+            ctx.listen(() => {
+                ctx.send({ abort: true });
+            });
+        });
+
+        expect(result).toStrictEqual({ res: [0], progress: 0.3333333333333333, aborted: true });
+    });
+
+    test('faulty listener', async () => {
+        const { mainDialog } = createWorker();
+
+        await mainDialog.withMessage('test').fetch({ n: 3 }, (ctx) => {
+            ctx.listen(() => {
+                throw new Error('Listener');
+            });
+        });
+
+        expect.assertions(0); // nothing happened
+    });
+
+    test('error', async () => {
+        const { mainDialog } = createWorker();
+        await expect(async () => mainDialog.withMessage('error').fetch()).rejects.toThrowError('Test');
+    });
+
+    test('close', async () => {
+        const { mainDialog, workerDialog } = createWorker();
+
+        mainDialog.close();
+        workerDialog.close();
+
+        expect(mainDialog.contexts.size).toBe(0);
+        expect(workerDialog.contexts.size).toBe(0);
+    });
+
+    test('empty message', async () => {
+        expect(() => createWorker().mainDialog.withMessage(undefined as any)).toThrowError(
+            'New context must have message',
+        );
+    });
+
+    test('empty ID', async () => {
+        const { mainDialog } = createWorker();
+        const first = mainDialog.withMessage('test');
+        expect(() => first.withMessage('error', '')).toThrowError('ID is required');
+    });
+
+    test('nesting', async () => {
+        const { mainDialog } = createWorker();
+        const first = mainDialog.withMessage('test');
+        const second = first.withMessage('error', 'x');
+        const third = second.withMessage('error');
+        expect(mainDialog.contexts.size).toBe(3);
+        expect(first.info).toBe('Main:*/1:test[open,request]');
+        first.close();
+        expect(mainDialog.contexts.size).toBe(0);
+        expect(first.debugInfo.closed).toBe(true);
+        expect(second.debugInfo.closed).toBe(true);
+        expect(third.debugInfo.closed).toBe(true);
+        expect(first.info).toBe('Main:*/1:test[closed,request]'); // id bumped from 0
+        expect(second.info).toBe('Main:1/x:error[closed,request]'); // new id
+        expect(third.info).toBe('Main:x/x:error[closed,request]'); // id kept
+        await expect(() => first.fetch({ n: 1 })).rejects.toThrowError(/Context 1 is closed/);
+    });
+});