@gueshbzh-perso/scanner 0.6.0 → 0.7.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@gueshbzh-perso/scanner",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Fast QR code & barcode scanning for the web: camera, WebGL frame pipeline, Web Worker and Rust/WebAssembly decoder.",
   "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/romainrodrigues/scanner"
+    "url": "https://github.com/RomainRodrigues/scanner"
   },
   "keywords": [
     "barcode",
@@ -33,6 +33,8 @@
   },
   "files": [
     "dist",
+    "src",
+    "!src/wasm",
     "README.md"
   ],
   "sideEffects": false,
@@ -42,7 +44,8 @@
     "build": "npm run build:wasm && npm run build:ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test:e2e": "node scripts/e2e.mjs",
-    "serve": "node scripts/serve.mjs"
+    "serve": "node scripts/serve.mjs",
+    "test": "node --test test/unit/*.test.mjs"
   },
   "devDependencies": {
     "binaryen": "^132.0.0",

package/src/camera.ts

@@ -0,0 +1,107 @@
+// Camera access helpers (getUserMedia, device listing, torch, zoom, focus).
+import type { CameraOptions, CameraResolution } from './types.js';
+
+const RESOLUTIONS: Record<CameraResolution, [number, number]> = {
+  sd: [640, 480],
+  hd: [1280, 720],
+  fhd: [1920, 1080],
+};
+
+// Namespaced: the host page shares localStorage with the SDK.
+const STORAGE_KEY = '@gueshbzh-perso/scanner:cameraId';
+/** Key used up to 0.6: still read, so the remembered camera survives the upgrade. */
+const LEGACY_STORAGE_KEY = 'scanner.cameraId';
+
+export function rememberedCamera(): string | undefined {
+  try {
+    return localStorage.getItem(STORAGE_KEY) ?? localStorage.getItem(LEGACY_STORAGE_KEY) ?? undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function rememberCamera(id: string | undefined): void {
+  try {
+    if (id) localStorage.setItem(STORAGE_KEY, id);
+  } catch {
+    /* storage unavailable: ignore */
+  }
+}
+
+export async function openCamera(options: CameraOptions = {}): Promise<MediaStream> {
+  if (!navigator.mediaDevices?.getUserMedia) {
+    throw new Error('Camera access is not available (a secure https:// context is required)');
+  }
+  const [width, height] = RESOLUTIONS[options.resolution ?? 'hd'];
+  const deviceId = options.deviceId ?? (options.rememberDevice !== false ? rememberedCamera() : undefined);
+
+  const video: MediaTrackConstraints = {
+    width: { ideal: width },
+    height: { ideal: height },
+    frameRate: { ideal: 30 },
+  };
+  if (deviceId) video.deviceId = { exact: deviceId };
+  else video.facingMode = { ideal: options.facingMode ?? 'environment' };
+
+  let stream: MediaStream;
+  try {
+    stream = await navigator.mediaDevices.getUserMedia({ video, audio: false });
+  } catch (err) {
+    // A remembered camera may have been unplugged: retry with the facing mode.
+    if (!deviceId || options.deviceId) throw err;
+    delete video.deviceId;
+    video.facingMode = { ideal: options.facingMode ?? 'environment' };
+    stream = await navigator.mediaDevices.getUserMedia({ video, audio: false });
+  }
+
+  const track = stream.getVideoTracks()[0];
+  if (track) await applyAdvanced(track, { focusMode: 'continuous' });
+  return stream;
+}
+
+/** Video input devices. Labels are only populated once camera permission was granted. */
+export async function listCameras(): Promise<MediaDeviceInfo[]> {
+  if (!navigator.mediaDevices?.enumerateDevices) return [];
+  const devices = await navigator.mediaDevices.enumerateDevices();
+  return devices.filter((d) => d.kind === 'videoinput');
+}
+
+interface ExtendedCapabilities extends MediaTrackCapabilities {
+  torch?: boolean;
+  zoom?: { min: number; max: number; step?: number };
+  focusMode?: string[];
+}
+
+export function capabilities(track: MediaStreamTrack | undefined): ExtendedCapabilities {
+  try {
+    return (track?.getCapabilities?.() ?? {}) as ExtendedCapabilities;
+  } catch {
+    return {};
+  }
+}
+
+export async function setTorch(track: MediaStreamTrack, on: boolean): Promise<void> {
+  if (!capabilities(track).torch) throw new Error('This camera has no controllable flashlight');
+  await track.applyConstraints({ advanced: [{ torch: on } as MediaTrackConstraintSet] });
+}
+
+export async function setZoom(track: MediaStreamTrack, zoom: number): Promise<void> {
+  const range = capabilities(track).zoom;
+  if (!range) throw new Error('This camera does not support zoom');
+  const value = Math.min(range.max, Math.max(range.min, zoom));
+  await track.applyConstraints({ advanced: [{ zoom: value } as MediaTrackConstraintSet] });
+}
+
+async function applyAdvanced(track: MediaStreamTrack, set: Record<string, unknown>): Promise<void> {
+  const caps = capabilities(track) as Record<string, unknown>;
+  const supported = Object.keys(set).filter((k) => {
+    const c = caps[k];
+    return Array.isArray(c) ? c.includes(set[k]) : c !== undefined;
+  });
+  if (supported.length === 0) return;
+  try {
+    await track.applyConstraints({ advanced: [Object.fromEntries(supported.map((k) => [k, set[k]]))] });
+  } catch {
+    /* best effort */
+  }
+}

package/src/core.ts

@@ -0,0 +1,189 @@
+// Engine core: owns the WebAssembly module and its objects.
+//
+// Two roles, so that frames can be decoded on several threads while a single
+// session keeps the state (strategy scheduling, multi-frame confirmation,
+// de-duplication):
+// - `SessionCore`: the session. Cheap calls (`plan`, `commit`), main thread.
+// - `DecoderCore`: the expensive decoding, one per Web Worker.
+// The inline engine (no Worker support) uses both on the main thread.
+import init, { WasmFrameDecoder, WasmScanner, WasmScanSession, version } from './wasm/scanner_wasm.js';
+import type { FramePlan, FrameReport, PixelFormat, ScanResult, WasmScanConfig } from './wasm/scanner_wasm.js';
+import type { Detection, EngineOptions } from './types.js';
+
+export type { FramePlan, FrameReport };
+
+/** Default location of the engine binary, next to this module. */
+export function defaultWasmUrl(): URL {
+  return new URL('./wasm/scanner_wasm_bg.wasm', import.meta.url);
+}
+
+/**
+ * Compile the engine once. The compiled module can be posted to any number
+ * of workers, which then only instantiate it (no second download or compile).
+ */
+export async function compileWasm(url: string | URL): Promise<WebAssembly.Module> {
+  const response = fetch(url);
+  try {
+    return await WebAssembly.compileStreaming(response);
+  } catch {
+    // Servers that do not send `application/wasm` reject streaming compilation.
+    return WebAssembly.compile(await (await response).arrayBuffer());
+  }
+}
+
+let initPromise: Promise<string> | null = null;
+
+/** Instantiate the engine in this realm (once). Returns the engine version. */
+export function loadWasm(source: string | URL | WebAssembly.Module): Promise<string> {
+  initPromise ??= init({ module_or_path: source }).then(() => version());
+  return initPromise;
+}
+
+/** Keep only the engine options (drops URLs and other non-cloneable values). */
+export function pickEngineOptions(o: EngineOptions): EngineOptions {
+  const { formats, preprocessing, tryInvert, maxResults, duplicateIntervalMs, linearConfirmations } = o;
+  return { formats, preprocessing, tryInvert, maxResults, duplicateIntervalMs, linearConfirmations };
+}
+
+export function toWasmConfig(o: EngineOptions, extra: Partial<WasmScanConfig> = {}): WasmScanConfig {
+  const cfg: WasmScanConfig = { ...extra };
+  if (o.formats) cfg.formats = o.formats;
+  if (o.preprocessing !== undefined) cfg.preprocessing = o.preprocessing;
+  if (o.tryInvert !== undefined) cfg.tryInvert = o.tryInvert;
+  if (o.maxResults !== undefined) cfg.maxResults = o.maxResults;
+  cfg.dedupCooldownMs = o.duplicateIntervalMs ?? 1500;
+  if (o.linearConfirmations !== undefined) cfg.linearConfirmations = o.linearConfirmations;
+  return cfg;
+}
+
+/**
+ * Configuration of camera sessions and their decoders: they must be equal,
+ * since a plan refers to the decoder's list of fallback strategies.
+ */
+function streamConfig(o: EngineOptions): WasmScanConfig {
+  // Back-pressure is handled by the SDK (frames are skipped, never queued),
+  // so the engine's own frame-skipping throttle would only drop useful frames.
+  return toWasmConfig(o, { adaptiveThrottle: false });
+}
+
+export function toDetection(r: ScanResult): Detection {
+  const d: Detection = { text: r.text, format: r.format, points: r.points, timestamp: r.timestampMs };
+  if (r.rawBytes) d.rawBytes = r.rawBytes;
+  return d;
+}
+
+export interface FrameOutcome {
+  /** New codes, or `null`. */
+  results: Detection[] | null;
+  /** Every code seen in this frame (including duplicates in cooldown). */
+  live: Detection[];
+  decodeMs: number;
+}
+
+/** The scan session of a camera stream (state only, cheap calls). */
+export class SessionCore {
+  private session: WasmScanSession | null = null;
+
+  configure(options: EngineOptions): void {
+    this.session?.free();
+    this.session = new WasmScanSession(streamConfig(options));
+  }
+
+  /** Strategy plan of the next frame, for a `DecoderCore` configured the same way. */
+  plan(): FramePlan {
+    return this.active().plan();
+  }
+
+  /** Record a decoded frame; returns the new codes and the live ones. */
+  commit(report: FrameReport): FrameOutcome {
+    const session = this.active();
+    const fresh = session.commit(report);
+    const results = fresh ? fresh.map(toDetection) : null;
+    return { results, live: results ?? session.lastDetections.map(toDetection), decodeMs: report.elapsedMs };
+  }
+
+  /** Decode on this thread (inline engine): plan, decode and commit at once. */
+  process(pixels: Uint8Array, width: number, height: number, format: PixelFormat): FrameOutcome {
+    const session = this.active();
+    // Write straight into WASM memory: avoids one more copy of the frame.
+    session.frameBuffer(pixels.length).set(pixels);
+    const t0 = performance.now();
+    const fresh = session.processFrameBuffer(width, height, format);
+    const decodeMs = performance.now() - t0;
+    const results = fresh ? fresh.map(toDetection) : null;
+    return { results, live: results ?? session.lastDetections.map(toDetection), decodeMs };
+  }
+
+  reset(): void {
+    this.session?.reset();
+  }
+
+  clearCooldown(text: string): void {
+    this.session?.clearCooldown(text);
+  }
+
+  destroy(): void {
+    this.session?.free();
+    this.session = null;
+  }
+
+  private active(): WasmScanSession {
+    if (!this.session) throw new Error('Engine not configured');
+    return this.session;
+  }
+}
+
+/** Frame decoding (stateless) and still-image scanning: the expensive part. */
+export class DecoderCore {
+  private decoder: WasmFrameDecoder | null = null;
+  private scanners = new Map<string, WasmScanner>();
+
+  configure(options: EngineOptions): void {
+    this.decoder?.free();
+    this.decoder = new WasmFrameDecoder(streamConfig(options));
+  }
+
+  decode(
+    pixels: Uint8Array,
+    width: number,
+    height: number,
+    format: PixelFormat,
+    plan: FramePlan,
+  ): FrameReport {
+    const decoder = this.decoder;
+    if (!decoder) throw new Error('Engine not configured');
+    decoder.frameBuffer(pixels.length).set(pixels);
+    return decoder.decodeFrameBuffer(width, height, format, plan);
+  }
+
+  /** One-shot scan of a still image, running every strategy. */
+  scan(
+    pixels: Uint8Array,
+    width: number,
+    height: number,
+    format: PixelFormat,
+    options: EngineOptions,
+  ): Detection[] {
+    const config = toWasmConfig(options);
+    const key = JSON.stringify(config);
+    let scanner = this.scanners.get(key);
+    if (!scanner) {
+      if (this.scanners.size >= 4) {
+        const [oldKey, old] = this.scanners.entries().next().value as [string, WasmScanner];
+        old.free();
+        this.scanners.delete(oldKey);
+      }
+      scanner = new WasmScanner(config);
+      this.scanners.set(key, scanner);
+    }
+    scanner.frameBuffer(pixels.length).set(pixels);
+    return scanner.scanFrameBuffer(width, height, format).map(toDetection);
+  }
+
+  destroy(): void {
+    this.decoder?.free();
+    this.decoder = null;
+    for (const s of this.scanners.values()) s.free();
+    this.scanners.clear();
+  }
+}

package/src/engine.ts

@@ -0,0 +1,348 @@
+// Decoding engine facade: same API whether decoding runs in Web Workers or inline.
+//
+// With workers, frames are decoded **in parallel** by a pool of stateless
+// decoders (one WebAssembly instance per worker), while the scan session
+// (strategy scheduling, multi-frame confirmation, de-duplication) runs on the
+// main thread: its calls take microseconds, and a single instance of the
+// state is what keeps confirmations and de-duplication correct across
+// workers. Decoding is CPU-bound and single-threaded per frame, so on phones
+// with many slow cores (Galaxy A14: decode ~125 ms) the pool multiplies the
+// frame rate.
+import { DecoderCore, SessionCore, compileWasm, defaultWasmUrl, loadWasm } from './core.js';
+import type { FramePlan, FrameReport } from './core.js';
+import type { WorkerRequest, WorkerResponse } from './protocol.js';
+import type { PixelFormat } from './wasm/scanner_wasm.js';
+import type { AssetOptions, Detection, EngineOptions } from './types.js';
+
+export interface FrameReply {
+  results: Detection[] | null;
+  live: Detection[];
+  decodeMs: number;
+  /** The pixel buffer, handed back for reuse. */
+  buffer: ArrayBuffer;
+}
+
+export interface Engine {
+  readonly inWorker: boolean;
+  readonly version: string;
+  /** Frames that can be decoded at the same time (number of workers). */
+  readonly concurrency: number;
+  configure(options: EngineOptions): Promise<void>;
+  /** Decode a camera frame. `buffer` is transferred and returned in the reply. */
+  processFrame(buffer: ArrayBuffer, width: number, height: number, format: PixelFormat): Promise<FrameReply>;
+  /** One-shot scan of a still image, running every strategy. */
+  scanImage(
+    buffer: ArrayBuffer,
+    width: number,
+    height: number,
+    format: PixelFormat,
+    options: EngineOptions,
+  ): Promise<Detection[]>;
+  reset(): Promise<void>;
+  clearCooldown(text: string): Promise<void>;
+  destroy(): void;
+}
+
+/**
+ * Default pool size: one worker per core, minus one for the main thread
+ * (camera, GPU, UI), capped at 3. Beyond 3 the frame rate is limited by the
+ * frame grab (~55 ms on a Galaxy A14, so ~18 fps) and more workers only cost
+ * memory (one WebAssembly instance each).
+ */
+export function defaultWorkerCount(): number {
+  const cores = typeof navigator !== 'undefined' ? navigator.hardwareConcurrency || 2 : 2;
+  return Math.min(3, Math.max(1, cores - 1));
+}
+
+type Distribute<T> = T extends unknown ? Omit<T, 'id'> : never;
+type Request = Distribute<WorkerRequest>;
+type OkResponse = Extract<WorkerResponse, { ok: true }>;
+
+/** One decoding worker, restarted if the engine crashes. */
+class DecoderWorker {
+  version = '';
+  /** Requests sent and not answered yet. */
+  busy = 0;
+
+  /** `false` once the worker failed for good (script error, crash outside a request). */
+  get alive(): boolean {
+    return this.dead === null;
+  }
+  private worker!: Worker;
+  private nextId = 1;
+  private pending = new Map<number, { resolve: (r: WorkerResponse) => void; reject: (e: Error) => void }>();
+  private dead: Error | null = null;
+  private options: EngineOptions | null = null;
+  private restarting: Promise<void> | null = null;
+
+  constructor(
+    private spawn: () => Worker,
+    private module: WebAssembly.Module,
+  ) {
+    this.attach(spawn());
+  }
+
+  private attach(worker: Worker) {
+    this.worker = worker;
+    worker.onmessage = (ev: MessageEvent<WorkerResponse>) => {
+      const p = this.pending.get(ev.data.id);
+      if (!p) return;
+      this.pending.delete(ev.data.id);
+      p.resolve(ev.data);
+    };
+    worker.onerror = (ev) => {
+      ev.preventDefault();
+      this.fail(new Error(ev.message || 'Scanner worker failed to load'));
+    };
+  }
+
+  private fail(err: Error) {
+    this.dead = err;
+    for (const p of this.pending.values()) p.reject(err);
+    this.pending.clear();
+  }
+
+  private call(req: Request, transfer: Transferable[] = []): Promise<WorkerResponse> {
+    if (this.dead) return Promise.reject(this.dead);
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.worker.postMessage({ ...req, id }, transfer);
+    });
+  }
+
+  /** Send a request; on a fatal engine crash, restart the worker before throwing. */
+  async ok(req: Request, transfer?: Transferable[]): Promise<OkResponse> {
+    this.busy++;
+    try {
+      if (this.restarting) await this.restarting;
+      const res = await this.call(req, transfer);
+      if (!res.ok) {
+        if (res.fatal) await this.restart();
+        throw Object.assign(new Error(res.error), { buffer: res.buffer });
+      }
+      return res;
+    } finally {
+      this.busy--;
+    }
+  }
+
+  private restart(): Promise<void> {
+    this.restarting ??= (async () => {
+      console.warn('[scanner] engine crashed, restarting worker');
+      this.worker.terminate();
+      this.attach(this.spawn());
+      await this.init();
+      if (this.options) await this.call({ type: 'configure', options: this.options });
+    })().finally(() => (this.restarting = null));
+    return this.restarting;
+  }
+
+  async init() {
+    const res = await this.call({ type: 'init', module: this.module });
+    if (!res.ok) throw new Error(res.error);
+    this.version = res.version ?? '';
+  }
+
+  async configure(options: EngineOptions) {
+    this.options = options;
+    await this.ok({ type: 'configure', options });
+  }
+
+  destroy() {
+    this.fail(new Error('Engine destroyed'));
+    this.worker.terminate();
+  }
+}
+
+/** A pool of decoding workers serving one scan session on the main thread. */
+class WorkerPoolEngine implements Engine {
+  readonly inWorker = true;
+  readonly version: string;
+  private session = new SessionCore();
+  private configured = false;
+  /** Bumped by `configure`: reports planned with an older configuration are dropped. */
+  private generation = 0;
+
+  constructor(private workers: DecoderWorker[]) {
+    this.version = workers[0]?.version ?? '';
+  }
+
+  get concurrency(): number {
+    return this.workers.length;
+  }
+
+  async configure(options: EngineOptions) {
+    // Session and decoders must share the configuration: a plan is an index
+    // in the decoder's list of fallback strategies.
+    this.generation++;
+    this.session.configure(options);
+    this.configured = true;
+    await Promise.all(this.workers.map((w) => w.configure(options)));
+  }
+
+  async processFrame(
+    buffer: ArrayBuffer,
+    width: number,
+    height: number,
+    format: PixelFormat,
+  ): Promise<FrameReply> {
+    if (!this.configured) throw new Error('Engine not configured');
+    const generation = this.generation;
+    const plan = this.session.plan();
+    let res: OkResponse;
+    try {
+      res = await this.idleWorker().ok({ type: 'decode', buffer, width, height, format, plan }, [buffer]);
+    } catch (err) {
+      // Every plan must be committed, or the scheduler keeps counting it as in flight.
+      this.session.commit(emptyReport(plan));
+      throw err;
+    }
+    const returned = res.buffer ?? new ArrayBuffer(width * height);
+    if (generation !== this.generation || !res.report) {
+      return { results: null, live: [], decodeMs: 0, buffer: returned };
+    }
+    return { ...this.session.commit(res.report), buffer: returned };
+  }
+
+  async scanImage(
+    buffer: ArrayBuffer,
+    width: number,
+    height: number,
+    format: PixelFormat,
+    options: EngineOptions,
+  ) {
+    const res = await this.idleWorker().ok({ type: 'scan', buffer, width, height, format, options }, [
+      buffer,
+    ]);
+    return res.results ?? [];
+  }
+
+  async reset() {
+    this.session.reset();
+  }
+
+  async clearCooldown(text: string) {
+    this.session.clearCooldown(text);
+  }
+
+  destroy() {
+    for (const w of this.workers) w.destroy();
+    this.session.destroy();
+  }
+
+  private idleWorker(): DecoderWorker {
+    const worker = pickWorker(this.workers);
+    if (!worker) throw new Error('Scanner engine unavailable: every decoding worker failed');
+    return worker;
+  }
+}
+
+/**
+ * The live worker with the fewest requests in progress. Dead workers are
+ * skipped: they reject instantly, so they always look the least busy and
+ * would otherwise receive most frames.
+ */
+export function pickWorker<W extends { alive: boolean; busy: number }>(workers: readonly W[]): W | undefined {
+  let best: W | undefined;
+  for (const w of workers) {
+    if (w.alive && (!best || w.busy < best.busy)) best = w;
+  }
+  return best;
+}
+
+function emptyReport(plan: FramePlan): FrameReport {
+  return { plan, results: [], fallbackRan: false, fallbackRead: false, elapsedMs: 0 };
+}
+
+/** Everything on the main thread (no Worker support). */
+class InlineEngine implements Engine {
+  readonly inWorker = false;
+  readonly concurrency = 1;
+  private session = new SessionCore();
+  private decoder = new DecoderCore();
+
+  constructor(readonly version: string) {}
+
+  async configure(options: EngineOptions) {
+    this.session.configure(options);
+  }
+
+  async processFrame(
+    buffer: ArrayBuffer,
+    width: number,
+    height: number,
+    format: PixelFormat,
+  ): Promise<FrameReply> {
+    return { ...this.session.process(new Uint8Array(buffer), width, height, format), buffer };
+  }
+
+  async scanImage(
+    buffer: ArrayBuffer,
+    width: number,
+    height: number,
+    format: PixelFormat,
+    options: EngineOptions,
+  ) {
+    return this.decoder.scan(new Uint8Array(buffer), width, height, format, options);
+  }
+
+  async reset() {
+    this.session.reset();
+  }
+
+  async clearCooldown(text: string) {
+    this.session.clearCooldown(text);
+  }
+
+  destroy() {
+    this.session.destroy();
+    this.decoder.destroy();
+  }
+}
+
+/**
+ * Load the engine: a pool of Web Workers when possible, else the main thread.
+ *
+ * Low-level API, for custom pipelines (frames you already have as pixels).
+ * Most applications should use `BarcodeReader` or `scanImage`. The `Engine`
+ * interface may gain members in minor versions.
+ */
+export async function createEngine(options: AssetOptions = {}): Promise<Engine> {
+  const wasmUrl = new URL(String(options.wasmUrl ?? defaultWasmUrl()), location.href).href;
+  // Compiled once here: the main thread needs the engine for the session,
+  // and the workers instantiate the same module without compiling it again.
+  const module = await compileWasm(wasmUrl);
+  const version = await loadWasm(module);
+
+  if (options.worker !== false && typeof Worker !== 'undefined') {
+    const workerUrl = options.workerUrl;
+    const spawn = () =>
+      workerUrl
+        ? new Worker(workerUrl, { type: 'module' })
+        : new Worker(new URL('./worker.js', import.meta.url), { type: 'module' });
+    const count = Math.max(1, Math.floor(options.workers ?? defaultWorkerCount()));
+    const workers: DecoderWorker[] = [];
+    try {
+      for (let i = 0; i < count; i++) workers.push(new DecoderWorker(spawn, module));
+      await Promise.all(workers.map((w) => w.init()));
+      return new WorkerPoolEngine(workers);
+    } catch (err) {
+      for (const w of workers) w.destroy();
+      console.warn('[scanner] Web Worker unavailable, decoding on the main thread:', err);
+    }
+  }
+
+  return new InlineEngine(version);
+}
+
+let shared: Promise<Engine> | null = null;
+
+/** Engine shared by `scanImage` calls (one worker is enough for still images). */
+export function sharedEngine(options?: AssetOptions): Promise<Engine> {
+  shared ??= createEngine({ ...options, workers: 1 }).catch((err) => {
+    shared = null;
+    throw err;
+  });
+  return shared;
+}