@xemahq/ui-kernel 0.9.0 → 0.9.2

package/src/lib/contribution-registry/contribution-registry.ts

@@ -0,0 +1,202 @@
+/**
+ * `createContributionRegistry` — the ONE two-layer closed+open registry core
+ * the Xema frontend uses everywhere a biome may contribute into a set the
+ * platform also ships a closed first-party version of.
+ *
+ * Before this module the exact same bookkeeping was hand-written four times
+ * (in-chat widgets, biome output renderers, open reply variants, and — next —
+ * Vista surfaces), each with slightly different guards. This is that core,
+ * extracted once (reuse register U1).
+ *
+ * ── The two layers ──────────────────────────────────────────────────────────
+ *   • a CLOSED first-party set, registered at module load and keyed by a
+ *     platform enum value;
+ *   • an OPEN biome set, registered at runtime (a biome registers from its
+ *     `FrontendBiome.init()` hook) and keyed by a namespaced `<biomeId>:<kind>`
+ *     slug.
+ *
+ * ── The invariants (all fail-loud, none silent) ─────────────────────────────
+ *   • RESERVED KINDS. Every first-party kind is reserved: `register()` throws
+ *     if a biome tries to claim one. The open set can never shadow the closed
+ *     one.
+ *   • DUPLICATE GUARD. Registering the EXACT same entry object twice is a
+ *     no-op (this is what tolerates React Fast Refresh / a double-invoked
+ *     `init()`); registering a DIFFERENT entry for a kind that is already
+ *     taken is an error — two biomes cannot silently shadow each other.
+ *   • The one exception is {@link DuplicateContributionPolicy.FirstWins}, for
+ *     registries rebuilt on a hot path where a throw would crash a render
+ *     (the biome output-renderer overlay). It is NOT a silent fallback: an
+ *     `onDuplicate` reporter is REQUIRED, and the registry factory throws at
+ *     construction if it is missing.
+ *
+ * Resolution itself lives in the caller (or in `renderable-registry.ts` for the
+ * versioned + payload-validated flavour) and NEVER throws.
+ */
+
+/** What to do when a DIFFERENT entry is registered for an already-taken kind. */
+export enum DuplicateContributionPolicy {
+  /**
+   * Throw. The default, and correct for every registry whose registrations
+   * happen once at module load or once per biome `init()`.
+   */
+  Throw = 'throw',
+  /**
+   * Keep the first registration and report the loser through `onDuplicate`.
+   * For registries REBUILT on a hot path (e.g. per render) where throwing
+   * would take down the UI. Requires `onDuplicate` — there is no silent mode.
+   */
+  FirstWins = 'first-wins',
+}
+
+/** Options for {@link createContributionRegistry}. */
+export interface ContributionRegistryOptions<TEntry> {
+  /** Registry name, used verbatim in every thrown message. */
+  readonly name: string;
+  /**
+   * The CLOSED first-party kinds. Reserved: `register()` refuses them so a
+   * biome can never shadow a platform kind. Typically `Object.values(SomeEnum)`.
+   */
+  readonly reservedKinds?: Iterable<string>;
+  /** Duplicate handling. Defaults to {@link DuplicateContributionPolicy.Throw}. */
+  readonly duplicatePolicy?: DuplicateContributionPolicy;
+  /**
+   * Reporter for a rejected duplicate under
+   * {@link DuplicateContributionPolicy.FirstWins}. REQUIRED under that policy.
+   */
+  readonly onDuplicate?: (
+    kind: string,
+    existing: TEntry,
+    rejected: TEntry,
+  ) => void;
+}
+
+/** The two-layer registry surface. */
+export interface ContributionRegistry<TEntry> {
+  /** Registry name (diagnostics). */
+  readonly name: string;
+  /**
+   * Register a FIRST-PARTY entry for a closed platform kind. Called once per
+   * kind at module load.
+   */
+  registerFirstParty(kind: string, entry: TEntry): void;
+  /**
+   * OPEN seam: register a biome entry under its namespaced `<biomeId>:<kind>`
+   * slug. Throws when the slug is a reserved first-party kind.
+   */
+  register(kind: string, entry: TEntry): void;
+  /** True when SOME entry (first-party or biome) is registered for the kind. */
+  has(kind: string): boolean;
+  /** The entry for a kind — first-party wins — or `undefined`. */
+  get(kind: string): TEntry | undefined;
+  /** True when the kind belongs to the closed first-party set. */
+  isReserved(kind: string): boolean;
+  /** Every registered kind (sorted) — diagnostics + tests. */
+  list(): readonly string[];
+  /** Only the OPEN (biome-contributed) kinds (sorted). */
+  listOpen(): readonly string[];
+  /** Flattened `kind -> entry` view, first-party wins. Diagnostics + overlays. */
+  entries(): ReadonlyMap<string, TEntry>;
+  /** Test-only: clear the OPEN set (the first-party set stays). */
+  __resetOpenForTests(): void;
+}
+
+export function createContributionRegistry<TEntry>(
+  options: ContributionRegistryOptions<TEntry>,
+): ContributionRegistry<TEntry> {
+  const {
+    name,
+    reservedKinds,
+    duplicatePolicy = DuplicateContributionPolicy.Throw,
+    onDuplicate,
+  } = options;
+
+  if (
+    duplicatePolicy === DuplicateContributionPolicy.FirstWins &&
+    onDuplicate === undefined
+  ) {
+    throw new Error(
+      `${name} registry: DuplicateContributionPolicy.FirstWins requires an ` +
+        `'onDuplicate' reporter — a dropped contribution must never be silent.`,
+    );
+  }
+
+  const reserved = new Set<string>(reservedKinds ?? []);
+  const firstParty = new Map<string, TEntry>();
+  const open = new Map<string, TEntry>();
+
+  /**
+   * Idempotent for the IDENTICAL entry (Fast Refresh / double-invoked
+   * `init()`); an error for a DIFFERENT one. Returns whether the entry landed.
+   */
+  function put(target: Map<string, TEntry>, kind: string, entry: TEntry): void {
+    const existing = target.get(kind);
+    if (existing === undefined) {
+      target.set(kind, entry);
+      return;
+    }
+    if (existing === entry) return;
+    if (duplicatePolicy === DuplicateContributionPolicy.FirstWins) {
+      // `onDuplicate` is guaranteed present under this policy (checked above).
+      (onDuplicate as (k: string, e: TEntry, r: TEntry) => void)(
+        kind,
+        existing,
+        entry,
+      );
+      return;
+    }
+    throw new Error(
+      `${name} registry: a DIFFERENT entry is already registered for kind ` +
+        `'${kind}'. Two contributors cannot claim the same slug.`,
+    );
+  }
+
+  return {
+    name,
+
+    registerFirstParty(kind: string, entry: TEntry): void {
+      put(firstParty, kind, entry);
+    },
+
+    register(kind: string, entry: TEntry): void {
+      if (reserved.has(kind)) {
+        throw new Error(
+          `${name} registry: '${kind}' is a reserved first-party kind and ` +
+            `cannot be overridden by a biome. Use a namespaced ` +
+            `'<biomeId>:${kind}' slug.`,
+        );
+      }
+      put(open, kind, entry);
+    },
+
+    has(kind: string): boolean {
+      return firstParty.has(kind) || open.has(kind);
+    },
+
+    get(kind: string): TEntry | undefined {
+      return firstParty.get(kind) ?? open.get(kind);
+    },
+
+    isReserved(kind: string): boolean {
+      return reserved.has(kind);
+    },
+
+    list(): readonly string[] {
+      return [...firstParty.keys(), ...open.keys()].sort();
+    },
+
+    listOpen(): readonly string[] {
+      return [...open.keys()].sort();
+    },
+
+    entries(): ReadonlyMap<string, TEntry> {
+      // First-party last so it wins on a key present in both (which `register`
+      // already forbids for reserved kinds, but `entries()` must not depend on
+      // that to be correct).
+      return new Map<string, TEntry>([...open, ...firstParty]);
+    },
+
+    __resetOpenForTests(): void {
+      open.clear();
+    },
+  };
+}

package/src/lib/contribution-registry/index.ts

@@ -0,0 +1,9 @@
+/**
+ * The shared two-layer (closed first-party + open biome) contribution registry
+ * core, and its versioned/validated renderable flavour.
+ *
+ * One implementation, four consumers: in-chat ChatWidgets, biome output
+ * renderers, open reply variants, and Vista surfaces.
+ */
+export * from './contribution-registry';
+export * from './renderable-registry';

package/src/lib/contribution-registry/renderable-registry.ts

@@ -0,0 +1,142 @@
+/**
+ * The RENDERABLE flavour of {@link createContributionRegistry}: a two-layer
+ * closed+open registry whose entries are versioned renderers with a narrowing
+ * payload validator, plus the fail-safe resolution every such plane needs.
+ *
+ * This is the shape the in-chat ChatWidget plane and the Vista render plane
+ * both want: an envelope `{ kind, version, payload }` arrives from an agent,
+ * and the frontend must turn it into something drawable WITHOUT ever throwing
+ * and WITHOUT ever silently drawing a coerced half-widget. Resolution returns a
+ * typed reason instead, which the caller renders as a safe fallback card.
+ */
+import {
+  createContributionRegistry,
+  type ContributionRegistry,
+  type ContributionRegistryOptions,
+} from './contribution-registry';
+
+/**
+ * Why an envelope fell back to the safe card. Populated on the resolution so
+ * the Studio debugger (and dev logs) can see WHY — mirrors the Model Resolution
+ * Matrix's `ResolvedModelDecision`. Closed set.
+ */
+export enum ContributionFallbackReason {
+  UnknownKind = 'unknown-kind',
+  InvalidPayload = 'invalid-payload',
+  UnsupportedVersion = 'unsupported-version',
+}
+
+/** The minimum an agent-emitted envelope must carry to be resolvable. */
+export interface ContributionEnvelope {
+  readonly kind: string;
+  readonly version: number;
+  readonly payload: unknown;
+}
+
+/**
+ * A versioned renderer. `validate` narrows the wire payload to the renderer's
+ * own type (returning `null` routes to the fallback with `InvalidPayload`) and
+ * MUST NOT throw; `render` draws from the narrowed payload.
+ */
+export interface RenderableContributionEntry<TRendered, TPayload = unknown> {
+  /** Highest schema version this renderer supports. */
+  readonly version: number;
+  /** Narrowing validator. Returns the typed payload, or `null`. MUST NOT throw. */
+  validate(payload: unknown): TPayload | null;
+  /** Draw from the narrowed payload. */
+  render(payload: TPayload): TRendered;
+}
+
+/** The outcome of resolving an envelope — inspectable for the Studio debugger. */
+export type RenderableResolution<TRendered> =
+  | {
+      readonly matched: true;
+      readonly kind: string;
+      readonly version: number;
+      readonly rendered: TRendered;
+    }
+  | {
+      readonly matched: false;
+      readonly kind: string;
+      readonly reason: ContributionFallbackReason;
+    };
+
+/** A {@link ContributionRegistry} of versioned renderers, plus `resolve`. */
+export interface RenderableContributionRegistry<TRendered>
+  extends Omit<
+    ContributionRegistry<RenderableContributionEntry<TRendered>>,
+    'registerFirstParty' | 'register'
+  > {
+  registerFirstParty<TPayload>(
+    kind: string,
+    entry: RenderableContributionEntry<TRendered, TPayload>,
+  ): void;
+  register<TPayload>(
+    kind: string,
+    entry: RenderableContributionEntry<TRendered, TPayload>,
+  ): void;
+  /**
+   * Resolve an envelope. Pure + deterministic so it can run in render, and it
+   * NEVER throws — an unknown kind, a payload the entry rejects, or a `version`
+   * newer than the entry supports ALL yield `matched: false` with a typed
+   * reason the caller renders as the safe fallback card.
+   */
+  resolve(envelope: ContributionEnvelope): RenderableResolution<TRendered>;
+}
+
+export function createRenderableContributionRegistry<TRendered>(
+  options: ContributionRegistryOptions<RenderableContributionEntry<TRendered>>,
+): RenderableContributionRegistry<TRendered> {
+  const registry =
+    createContributionRegistry<RenderableContributionEntry<TRendered>>(options);
+
+  return {
+    ...registry,
+
+    registerFirstParty<TPayload>(
+      kind: string,
+      entry: RenderableContributionEntry<TRendered, TPayload>,
+    ): void {
+      registry.registerFirstParty(kind, entry);
+    },
+
+    register<TPayload>(
+      kind: string,
+      entry: RenderableContributionEntry<TRendered, TPayload>,
+    ): void {
+      registry.register(kind, entry);
+    },
+
+    resolve(envelope: ContributionEnvelope): RenderableResolution<TRendered> {
+      const entry = registry.get(envelope.kind);
+      if (entry === undefined) {
+        return {
+          matched: false,
+          kind: envelope.kind,
+          reason: ContributionFallbackReason.UnknownKind,
+        };
+      }
+      if (envelope.version > entry.version) {
+        return {
+          matched: false,
+          kind: envelope.kind,
+          reason: ContributionFallbackReason.UnsupportedVersion,
+        };
+      }
+      const narrowed = entry.validate(envelope.payload);
+      if (narrowed === null) {
+        return {
+          matched: false,
+          kind: envelope.kind,
+          reason: ContributionFallbackReason.InvalidPayload,
+        };
+      }
+      return {
+        matched: true,
+        kind: envelope.kind,
+        version: entry.version,
+        rendered: entry.render(narrowed),
+      };
+    },
+  };
+}

package/src/lib/system-bus/deeplink.ts

@@ -144,7 +144,7 @@ export function parseDeeplink(raw: string): ParsedDeeplink {
       }
       return {
         kind: DeeplinkTargetKind.Object,
-        objectRef: `${DEEPLINK_SCHEME}${body}` as `xema://${string}`,
+        objectRef: `${DEEPLINK_SCHEME}${body}`,
       };
     }
     case DeeplinkTargetKind.Capability: {

package/src/lib/system-bus/host-ports.ts

@@ -3,6 +3,7 @@ import type {
   CapabilityInvokeMeta,
   CapabilityInvokeResult,
 } from './capability-invoke';
+import type { ParsedDeeplink } from './deeplink';
 import type { PaletteEntry, PaletteQuery } from './palette';
 import type {
   OpenWindowRequest,
@@ -92,5 +93,5 @@ export interface WindowManager {
  * window) — fail-fast, never a silent no-op.
  */
 export interface DeeplinkResolver {
-  resolve(target: import('./deeplink').ParsedDeeplink): Promise<void>;
+  resolve(target: ParsedDeeplink): Promise<void>;
 }

package/src/lib/system-bus/intent-registry.ts

@@ -5,7 +5,6 @@ import {
 } from '@xemahq/kernel-contracts/object';
 import { ActionRefKind } from './enums';
 import type {
-  ActionRef,
   IntentBus,
   IntentRegistration,
   ResolvedIntent,
@@ -24,7 +23,7 @@ function assertValidRegistration(registration: IntentRegistration): void {
     if (!VALID_ACTION_KINDS.has(action.kind)) {
       throw new Error(
         `[xema-ui-kernel] IntentRegistration from "${registration.biomeId}" ` +
-          `has an ActionRef with unknown kind "${(action as ActionRef).kind}". ` +
+          `has an ActionRef with unknown kind "${action.kind}". ` +
           `Expected one of: ${[...VALID_ACTION_KINDS].join(', ')}.`,
       );
     }

package/src/offline/index.ts

@@ -41,11 +41,13 @@ export {
 } from './mutation';
 export {
   OutboxProvider,
+  type OutboxProviderProps,
+} from './react';
+export {
   useOutbox,
   useOutboxSnapshot,
   useOnlineStatus,
-  type OutboxProviderProps,
-} from './react';
+} from './react-hooks';
 export {
   OfflineStatusBadge,
   type OfflineStatusBadgeProps,

package/src/offline/offline-status-badge.tsx

@@ -1,4 +1,4 @@
-import { useOutboxSnapshot } from './react';
+import { useOutboxSnapshot } from './react-hooks';
 
 import type { Outbox } from './outbox';
 

package/src/offline/outbox.test.ts

@@ -25,7 +25,7 @@ function makeOutbox(overrides: Partial<OutboxOptions> = {}): {
 describe('Outbox', () => {
   it('queues while offline and delivers on reconnect', async () => {
     const { outbox, online } = makeOutbox();
-    const send = vi.fn(async () => {});
+    const send = vi.fn(() => Promise.resolve());
     outbox.registerExecutor(KIND, send);
 
     online.reportOffline();
@@ -42,8 +42,9 @@ describe('Outbox', () => {
   it('delivers immediately when online and removes the entry; idempotency key is stable', async () => {
     const { outbox } = makeOutbox();
     const keys: string[] = [];
-    outbox.registerExecutor(KIND, async (_p, ctx: OutboxExecuteContext) => {
+    outbox.registerExecutor(KIND, (_p, ctx: OutboxExecuteContext) => {
       keys.push(ctx.idempotencyKey);
+      return Promise.resolve();
     });
     await outbox.enqueue(KIND, { a: 1 });
     await outbox.drain();
@@ -55,11 +56,12 @@ describe('Outbox', () => {
   it('retries a 5xx and eventually succeeds', async () => {
     const { outbox } = makeOutbox();
     let calls = 0;
-    outbox.registerExecutor(KIND, async () => {
+    outbox.registerExecutor(KIND, () => {
       calls += 1;
       if (calls < 3) {
-        throw { status: 503, message: 'unavailable' };
+        return Promise.reject({ status: 503, message: 'unavailable' });
       }
+      return Promise.resolve();
     });
     await outbox.enqueue(KIND, { a: 1 });
     await outbox.drain();
@@ -69,29 +71,29 @@ describe('Outbox', () => {
 
   it('dead-letters a 4xx immediately (no pointless retries)', async () => {
     const { outbox } = makeOutbox();
-    const send = vi.fn(async () => {
-      throw { status: 400, message: 'bad request' };
-    });
+    const send = vi.fn(() =>
+      Promise.reject({ status: 400, message: 'bad request' }),
+    );
     outbox.registerExecutor(KIND, send);
     await outbox.enqueue(KIND, { a: 1 });
     await outbox.drain();
     expect(send).toHaveBeenCalledTimes(1);
     const snap = outbox.getSnapshot();
     expect(snap.failedCount).toBe(1);
-    expect(snap.entries[0]!.status).toBe(OutboxEntryStatus.Failed);
+    expect(snap.entries[0].status).toBe(OutboxEntryStatus.Failed);
   });
 
   it('dead-letters after exhausting retries on persistent 5xx', async () => {
     const { outbox } = makeOutbox({ maxAttempts: 3 });
     let calls = 0;
-    outbox.registerExecutor(KIND, async () => {
+    outbox.registerExecutor(KIND, () => {
       calls += 1;
-      throw { status: 503 };
+      return Promise.reject({ status: 503 });
     });
     await outbox.enqueue(KIND, { a: 1 });
     await outbox.drain();
     expect(calls).toBe(3);
-    expect(outbox.getSnapshot().entries[0]!.status).toBe(OutboxEntryStatus.Failed);
+    expect(outbox.getSnapshot().entries[0].status).toBe(OutboxEntryStatus.Failed);
   });
 
   it('a network failure never advances the attempt counter or dead-letters', async () => {
@@ -99,15 +101,19 @@ describe('Outbox', () => {
     const timers: Array<() => void> = [];
     const { outbox } = makeOutbox({ scheduler: (fn) => void timers.push(fn) });
     let succeed = false;
-    outbox.registerExecutor(KIND, async () => {
+    outbox.registerExecutor(KIND, () => {
       if (!succeed) {
-        throw { name: 'TypeError', message: 'Failed to fetch' };
+        return Promise.reject({
+          name: 'TypeError',
+          message: 'Failed to fetch',
+        });
       }
+      return Promise.resolve();
     });
 
     await outbox.enqueue(KIND, { a: 1 });
     await outbox.drain();
-    const parked = outbox.getSnapshot().entries[0]!;
+    const parked = outbox.getSnapshot().entries[0];
     expect(parked.status).toBe(OutboxEntryStatus.Pending);
     expect(parked.attempts).toBe(0); // offline is not the payload's fault
     expect(outbox.getSnapshot().failedCount).toBe(0);
@@ -121,8 +127,9 @@ describe('Outbox', () => {
   it('delivers queued entries in FIFO order', async () => {
     const { outbox, online } = makeOutbox();
     const order: number[] = [];
-    outbox.registerExecutor(KIND, async (p: { n: number }) => {
+    outbox.registerExecutor(KIND, (p: { n: number }) => {
       order.push(p.n);
+      return Promise.resolve();
     });
     online.reportOffline();
     await outbox.enqueue(KIND, { n: 1 });
@@ -150,7 +157,7 @@ describe('Outbox', () => {
     online.reportOffline(); // keep it queued so we can observe the recovery
     const outbox = new Outbox({ storage, online, scheduler: (fn) => fn() });
     await outbox.start();
-    expect(outbox.getSnapshot().entries[0]!.status).toBe(OutboxEntryStatus.Pending);
+    expect(outbox.getSnapshot().entries[0].status).toBe(OutboxEntryStatus.Pending);
     outbox.stop();
   });
 });

package/src/offline/outbox.ts

@@ -159,7 +159,7 @@ export class Outbox {
       updatedAt: ts,
       ...(opts.label !== undefined ? { label: opts.label } : {}),
     };
-    await this.storage.put(entry as OutboxEntry);
+    await this.storage.put(entry);
     await this.refresh();
     void this.drain();
     return entry;

package/src/offline/react-hooks.ts

@@ -0,0 +1,37 @@
+import { createContext, useContext, useSyncExternalStore } from 'react';
+
+import { Outbox } from './outbox';
+
+import type { OutboxSnapshot } from './types';
+
+export const OutboxContext = createContext<Outbox | null>(null);
+
+export function useOutbox(): Outbox {
+  const ctx = useContext(OutboxContext);
+  if (!ctx) {
+    throw new Error('useOutbox must be used within an <OutboxProvider>.');
+  }
+  return ctx;
+}
+
+function resolveOutbox(explicit: Outbox | undefined, ctx: Outbox | null): Outbox {
+  const instance = explicit ?? ctx;
+  if (!instance) {
+    throw new Error('An <OutboxProvider> or an explicit outbox is required.');
+  }
+  return instance;
+}
+
+export function useOutboxSnapshot(outbox?: Outbox): OutboxSnapshot {
+  const ctx = useContext(OutboxContext);
+  const instance = resolveOutbox(outbox, ctx);
+  return useSyncExternalStore(
+    (cb) => instance.subscribe(cb),
+    () => instance.getSnapshot(),
+    () => instance.getSnapshot(),
+  );
+}
+
+export function useOnlineStatus(outbox?: Outbox): boolean {
+  return useOutboxSnapshot(outbox).online;
+}

package/src/offline/react.tsx

@@ -1,18 +1,12 @@
 import {
-  createContext,
-  useContext,
   useEffect,
   useMemo,
   useRef,
-  useSyncExternalStore,
   type ReactNode,
 } from 'react';
 
 import { Outbox, type OutboxOptions } from './outbox';
-
-import type { OutboxSnapshot } from './types';
-
-const OutboxContext = createContext<Outbox | null>(null);
+import { OutboxContext } from './react-hooks';
 
 export interface OutboxProviderProps {
   /** Bring your own Outbox, or let the provider create one from `options`. */
@@ -36,36 +30,3 @@ export function OutboxProvider({ outbox, options, children }: OutboxProviderProp
 
   return <OutboxContext.Provider value={instance}>{children}</OutboxContext.Provider>;
 }
-
-export function useOutbox(): Outbox {
-  const ctx = useContext(OutboxContext);
-  if (!ctx) {
-    throw new Error('useOutbox must be used within an <OutboxProvider>.');
-  }
-  return ctx;
-}
-
-function resolveOutbox(explicit: Outbox | undefined, ctx: Outbox | null): Outbox {
-  const instance = explicit ?? ctx;
-  if (!instance) {
-    throw new Error('An <OutboxProvider> or an explicit outbox is required.');
-  }
-  return instance;
-}
-
-/** Subscribe to the outbox state (offline badge, pending count, dead-letter
- *  list). Re-renders only when the snapshot changes. */
-export function useOutboxSnapshot(outbox?: Outbox): OutboxSnapshot {
-  const ctx = useContext(OutboxContext);
-  const instance = resolveOutbox(outbox, ctx);
-  return useSyncExternalStore(
-    (cb) => instance.subscribe(cb),
-    () => instance.getSnapshot(),
-    () => instance.getSnapshot(),
-  );
-}
-
-/** Current connectivity as tracked by the outbox. */
-export function useOnlineStatus(outbox?: Outbox): boolean {
-  return useOutboxSnapshot(outbox).online;
-}

package/src/offline/storage.ts

@@ -4,20 +4,25 @@ import type { OutboxEntry, OutboxStorage } from './types';
 export class InMemoryOutboxStorage implements OutboxStorage {
   private readonly map = new Map<string, OutboxEntry>();
 
-  async getAll(): Promise<OutboxEntry[]> {
-    return [...this.map.values()].sort((a, b) => a.createdAt - b.createdAt);
+  getAll(): Promise<OutboxEntry[]> {
+    return Promise.resolve(
+      [...this.map.values()].sort((a, b) => a.createdAt - b.createdAt),
+    );
   }
 
-  async put(entry: OutboxEntry): Promise<void> {
+  put(entry: OutboxEntry): Promise<void> {
     this.map.set(entry.id, { ...entry });
+    return Promise.resolve();
   }
 
-  async delete(id: string): Promise<void> {
+  delete(id: string): Promise<void> {
     this.map.delete(id);
+    return Promise.resolve();
   }
 
-  async clear(): Promise<void> {
+  clear(): Promise<void> {
     this.map.clear();
+    return Promise.resolve();
   }
 }
 
@@ -69,7 +74,7 @@ export class IndexedDbOutboxStorage implements OutboxStorage {
       transaction.onabort = () =>
         reject(transaction.error ?? new Error('indexedDB tx aborted'));
       transaction.oncomplete = () =>
-        resolve(request ? (request as IDBRequest<T>).result : undefined);
+        resolve(request ? request.result : undefined);
       transaction.onerror = () =>
         reject(transaction.error ?? new Error('indexedDB tx error'));
     });