ignotum 0.0.13 → 0.0.15

package/src/client/managed-upgrade.ts

@@ -0,0 +1,283 @@
+import {
+  ExecutionSelection,
+  RecoverySessionId,
+  sameExecutionSelection,
+} from "@ignotum/contracts/platform";
+import * as Versioned from "@ignotum/contracts/versioned";
+import { AppId } from "@ignotum/contracts/runtime/identity";
+import { Option, Schema } from "effect";
+
+const TabStateV1 = Schema.Struct({
+  formatVersion: Schema.Literal(1),
+  appId: AppId,
+  clientSessionId: RecoverySessionId,
+  attempts: Schema.Natural.check(Schema.isLessThanOrEqualTo(3)),
+  attemptedAt: Schema.Natural,
+  target: Schema.NullOr(ExecutionSelection),
+  uncertainStorage: Schema.Boolean,
+}).annotate({ parseOptions: { onExcessProperty: "error" } });
+const TabState = Versioned.initial(TabStateV1);
+const TabStateJson = Schema.fromJsonString(TabState);
+
+export interface ManagedUpdateSnapshot {
+  readonly phase: "connecting" | "ready" | "settling" | "reloading" | "error";
+  readonly message?: string;
+  readonly recovery: readonly string[];
+}
+
+export interface ManagedUpgradeBrowser {
+  readonly crypto: Pick<Crypto, "randomUUID">;
+  readonly sessionStorage: Pick<Storage, "getItem" | "setItem">;
+  readonly history: Pick<History, "state" | "replaceState">;
+  readonly location: Pick<Location, "href">;
+  readonly fetch: typeof fetch;
+}
+
+/** One attempt owns admission, the settling deadline, and the reload across target changes. */
+export class ManagedUpgrade {
+  readonly clientSessionId: RecoverySessionId;
+  private readonly key: string;
+  private tab: typeof TabState.Type;
+  private snapshot: ManagedUpdateSnapshot = { phase: "connecting", recovery: [] };
+  private readonly listeners = new Set<() => void>();
+  private target: ExecutionSelection | undefined;
+  private attempt: Promise<void> | undefined;
+  private disposed = false;
+  private storageAvailable = true;
+  private readyTimer: ReturnType<typeof setTimeout> | undefined;
+
+  constructor(
+    readonly selection: ExecutionSelection,
+    private readonly browser: ManagedUpgradeBrowser,
+    private readonly callbacks: {
+      readonly stopAdmission: () => void;
+      readonly unresolved: () => number;
+      readonly persist: () => readonly string[];
+      readonly reload: () => void;
+      readonly freshSelection: () => Promise<ExecutionSelection | undefined>;
+    },
+  ) {
+    this.key = `ignotum.managed.tab.${selection.appId}`;
+    this.tab = {
+      formatVersion: 1,
+      appId: selection.appId,
+      clientSessionId: RecoverySessionId.make(
+        `rec_${browser.crypto.randomUUID().replaceAll("-", "").slice(0, 24)}`,
+      ),
+      attempts: 0,
+      attemptedAt: 0,
+      target: null,
+      uncertainStorage: false,
+    };
+    try {
+      const raw = browser.sessionStorage.getItem(this.key);
+      if (raw !== null) {
+        const decoded = Schema.decodeOption(TabStateJson)(raw);
+        if (
+          Option.isSome(decoded) &&
+          decoded.value.appId === selection.appId &&
+          (decoded.value.target === null || decoded.value.target.appId === selection.appId)
+        ) {
+          this.tab = decoded.value;
+        } else {
+          this.reportRecovery(
+            "Saved update information could not be read. Previous mutation outcomes may be unknown.",
+          );
+        }
+      }
+    } catch {
+      this.storageAvailable = false;
+    }
+    const history = Schema.decodeUnknownOption(Schema.Struct({ __ignotumUpdate: TabState }))(
+      browser.history.state,
+    );
+    if (
+      Option.isSome(history) &&
+      history.value.__ignotumUpdate.appId === selection.appId &&
+      history.value.__ignotumUpdate.attemptedAt >= this.tab.attemptedAt &&
+      (history.value.__ignotumUpdate.target === null ||
+        history.value.__ignotumUpdate.target.appId === selection.appId)
+    )
+      this.tab = history.value.__ignotumUpdate;
+    if (this.tab.uncertainStorage)
+      this.reportRecovery(
+        "Some previous mutation outcomes could not be saved in browser storage and remain unknown.",
+      );
+    this.clientSessionId = this.tab.clientSessionId;
+    this.save();
+  }
+
+  getSnapshot = (): ManagedUpdateSnapshot => this.snapshot;
+  subscribe = (listener: () => void): (() => void) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  private update(next: ManagedUpdateSnapshot): void {
+    if (this.disposed) return;
+    this.snapshot = next;
+    for (const listener of this.listeners) listener();
+  }
+  reportRecovery(message: string): void {
+    if (!this.snapshot.recovery.includes(message))
+      this.update({ ...this.snapshot, recovery: [...this.snapshot.recovery, message].slice(-100) });
+  }
+  dismissRecovery = (): void => {
+    this.tab = { ...this.tab, uncertainStorage: false };
+    this.save();
+    this.update({ ...this.snapshot, recovery: [] });
+  };
+  private save(): boolean {
+    let saved = false;
+    try {
+      this.browser.sessionStorage.setItem(this.key, Schema.encodeSync(TabStateJson)(this.tab));
+      this.storageAvailable = true;
+      saved = true;
+    } catch {
+      this.storageAvailable = false;
+    }
+    try {
+      const existing = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.Unknown))(
+        this.browser.history.state,
+      );
+      this.browser.history.replaceState(
+        {
+          ...Option.getOrElse(existing, () => ({})),
+          __ignotumUpdate: Schema.encodeSync(TabState)(this.tab),
+        },
+        "",
+      );
+      saved = true;
+    } catch {
+      /* The automatic retry budget must survive reload through at least one browser store. */
+    }
+    return saved;
+  }
+  get obsolete(): boolean {
+    return this.target !== undefined || this.attempt !== undefined;
+  }
+  get ready(): boolean {
+    return this.snapshot.phase === "ready" && !this.obsolete;
+  }
+  connecting(): void {
+    if (this.readyTimer !== undefined) clearTimeout(this.readyTimer);
+    if (!this.obsolete) this.update({ ...this.snapshot, phase: "connecting", message: undefined });
+  }
+  accepted(): void {
+    if (this.obsolete) return;
+    this.update({ ...this.snapshot, phase: "ready", message: undefined });
+    if (this.readyTimer !== undefined) clearTimeout(this.readyTimer);
+    // A repeatedly broken lazy asset must not reset the reload budget at every handshake.
+    this.readyTimer = setTimeout(() => {
+      this.tab = { ...this.tab, attempts: 0, attemptedAt: 0, target: null };
+      this.save();
+    }, 60_000);
+  }
+  unavailable(message = "The app could not check for updates. Reconnect and try again."): void {
+    if (this.readyTimer !== undefined) clearTimeout(this.readyTimer);
+    if (!this.obsolete) this.update({ ...this.snapshot, phase: "error", message });
+  }
+  require(target?: ExecutionSelection): Promise<void> {
+    if (this.disposed) return Promise.resolve();
+    if (target !== undefined) this.target = target;
+    this.callbacks.stopAdmission();
+    if (this.attempt !== undefined && this.snapshot.phase !== "error") return this.attempt;
+    if (this.readyTimer !== undefined) clearTimeout(this.readyTimer);
+    this.update({
+      ...this.snapshot,
+      phase: "settling",
+      message: "Updating the app. Waiting briefly for pending changes…",
+    });
+    this.attempt = this.run();
+    return this.attempt;
+  }
+  private async run(): Promise<void> {
+    const deadline = Date.now() + 2_000;
+    while (!this.disposed && this.callbacks.unresolved() > 0 && Date.now() < deadline)
+      await new Promise<void>((resolve) => setTimeout(resolve, 25));
+    if (this.disposed) return;
+    try {
+      const issues = this.callbacks.persist();
+      for (const issue of issues) this.reportRecovery(issue);
+      if (issues.length > 0) {
+        this.tab = { ...this.tab, uncertainStorage: true };
+        await new Promise<void>((resolve) => setTimeout(resolve, 1_000));
+      }
+      const fresh = await this.callbacks.freshSelection();
+      if (fresh !== undefined && fresh.appId !== this.selection.appId)
+        throw new Error("The app address now refers to a different app.");
+      this.target = fresh ?? this.target;
+      const response = await this.browser.fetch(this.browser.location.href, {
+        cache: "no-store",
+        credentials: "same-origin",
+        headers: { accept: "text/html" },
+        signal: AbortSignal.timeout(10_000),
+      });
+      if (!response.ok) throw new Error("The updated app document is temporarily unavailable.");
+      await response.body?.cancel();
+      if (this.disposed) return;
+      // A verified new selection starts a separate update budget.
+      const attempts =
+        fresh !== undefined &&
+        this.tab.target !== null &&
+        !sameExecutionSelection(this.tab.target, fresh)
+          ? 0
+          : this.tab.attempts;
+      if (attempts >= 2)
+        throw new Error(
+          "The app update could not load a consistent release. Try again when the connection or release is available.",
+        );
+      this.tab = {
+        ...this.tab,
+        attempts: attempts + 1,
+        attemptedAt: Date.now(),
+        target: fresh ?? this.target ?? this.selection,
+      };
+      if (!this.save()) {
+        throw new Error(
+          "Browser storage is unavailable. Pending changes may have unknown outcomes. Use Reload app to continue the update.",
+        );
+      }
+      this.update({ ...this.snapshot, phase: "reloading", message: "Loading the updated app…" });
+      this.callbacks.reload();
+    } catch (error) {
+      this.update({
+        ...this.snapshot,
+        phase: "error",
+        message:
+          error instanceof Error ? error.message : "The app update could not be loaded. Try again.",
+      });
+    }
+  }
+  /** An explicit retry resets the automatic budget, while obsolete code remains fenced. */
+  retry = (): void => {
+    if (this.disposed) return;
+    if (!this.storageAvailable) {
+      this.callbacks.persist();
+      this.callbacks.reload();
+      return;
+    }
+    this.tab = { ...this.tab, attempts: 0, attemptedAt: 0 };
+    this.save();
+    this.attempt = undefined;
+    void this.require(this.target);
+  };
+  async check(): Promise<boolean> {
+    if (this.obsolete || this.disposed) return false;
+    try {
+      const fresh = await this.callbacks.freshSelection();
+      if (fresh === undefined || !sameExecutionSelection(this.selection, fresh)) {
+        void this.require(fresh);
+        return false;
+      }
+      return !this.obsolete && !this.disposed;
+    } catch {
+      this.unavailable();
+      return false;
+    }
+  }
+  dispose(): void {
+    this.disposed = true;
+    if (this.readyTimer !== undefined) clearTimeout(this.readyTimer);
+    this.listeners.clear();
+  }
+}

package/src/client/recovery-journal.ts

@@ -0,0 +1,195 @@
+import { RecoveryIdentity, RecoverySessionId } from "@ignotum/contracts/platform";
+import { AppId } from "@ignotum/contracts/runtime/identity";
+import * as Versioned from "@ignotum/contracts/versioned";
+import { DateTime, Predicate, Schema } from "effect";
+
+export const RecoveryJournalLimits = {
+  maxEntries: 100,
+  retentionMs: 24 * 60 * 60 * 1000,
+  maxBytes: 64 * 1024,
+} as const;
+const RecoveryEntry = Schema.Struct({
+  identity: RecoveryIdentity,
+  recordedAt: Schema.Natural,
+  expiresAt: Schema.Natural,
+  state: Schema.Literals(["pending", "settled", "interrupted", "uncertain"]),
+});
+export type RecoveryJournalEntry = typeof RecoveryEntry.Type;
+const RecoveryJournalV1 = Schema.Struct({
+  formatVersion: Schema.Literal(1),
+  appId: AppId,
+  sessionEpoch: Schema.String,
+  clientSessionId: RecoverySessionId,
+  entries: Schema.Array(RecoveryEntry).check(Schema.isMaxLength(RecoveryJournalLimits.maxEntries)),
+})
+  .check(
+    Schema.makeFilter((record) => {
+      const keys = record.entries.map((entry) => identityKey(entry.identity));
+      return (
+        new Set(keys).size === keys.length &&
+        record.entries.every(
+          (entry) =>
+            entry.identity.originalSelection.appId === record.appId &&
+            entry.expiresAt > entry.recordedAt &&
+            entry.expiresAt - entry.recordedAt <= RecoveryJournalLimits.retentionMs,
+        )
+      );
+    }),
+  )
+  .annotate({ parseOptions: { onExcessProperty: "error" } });
+export const RecoveryJournalRecord = Versioned.initial(RecoveryJournalV1);
+export type RecoveryJournalRecord = typeof RecoveryJournalRecord.Type;
+export type RecoveryJournalIssue = "denied" | "corrupt" | "full" | "expired" | "session-changed";
+export interface RecoveryJournalSnapshot {
+  readonly clientSessionId: RecoverySessionId;
+  readonly entries: ReadonlyArray<RecoveryJournalEntry>;
+  readonly issues: ReadonlyArray<RecoveryJournalIssue>;
+}
+type JournalStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">;
+export interface RecoveryJournalOptions {
+  readonly appId: AppId;
+  readonly sessionEpoch: string;
+  readonly clientSessionId: RecoverySessionId;
+  readonly storage?: JournalStorage | (() => JournalStorage);
+  readonly now?: () => number;
+}
+const identityKey = (identity: RecoveryIdentity): string =>
+  `${identity.originalSelection.dataHistoryId}/${identity.invocationId}`;
+const bytes = (value: string): number => new TextEncoder().encode(value).byteLength;
+
+/** sessionStorage isolates tabs. A cloned tab may look up copied identities, never replay them. */
+export class RecoveryJournal {
+  readonly storageKey: string;
+  private clientSessionId: RecoverySessionId;
+  constructor(private readonly options: RecoveryJournalOptions) {
+    this.storageKey = `ignotum:recovery:${options.appId}`;
+    this.clientSessionId = options.clientSessionId;
+  }
+  private storage(): JournalStorage {
+    const storage = this.options.storage;
+    return storage === undefined
+      ? globalThis.sessionStorage
+      : Predicate.isFunction(storage)
+        ? storage()
+        : storage;
+  }
+  private now(): number {
+    return this.options.now?.() ?? DateTime.toEpochMillis(DateTime.nowUnsafe());
+  }
+  private snapshot(
+    entries: ReadonlyArray<RecoveryJournalEntry>,
+    issues: ReadonlyArray<RecoveryJournalIssue>,
+  ): RecoveryJournalSnapshot {
+    return { clientSessionId: this.clientSessionId, entries, issues };
+  }
+  read(): RecoveryJournalSnapshot {
+    let raw: string | null;
+    try {
+      raw = this.storage().getItem(this.storageKey);
+    } catch {
+      return this.snapshot([], ["denied"]);
+    }
+    if (raw === null) return this.snapshot([], []);
+    if (bytes(raw) > RecoveryJournalLimits.maxBytes) return this.discard("full");
+    const parsed = Schema.decodeUnknownOption(Schema.fromJsonString(RecoveryJournalRecord))(raw);
+    if (parsed._tag === "None" || parsed.value.appId !== this.options.appId)
+      return this.discard("corrupt");
+    if (parsed.value.sessionEpoch !== this.options.sessionEpoch)
+      return this.discard("session-changed");
+    this.clientSessionId = parsed.value.clientSessionId;
+    const now = this.now();
+    const entries = parsed.value.entries.filter(
+      (entry) => entry.expiresAt > now && entry.recordedAt <= now,
+    );
+    const issues: RecoveryJournalIssue[] =
+      entries.length === parsed.value.entries.length ? [] : ["expired"];
+    return issues.length === 0 ? this.snapshot(entries, issues) : this.persist(entries, issues);
+  }
+  private discard(issue: RecoveryJournalIssue): RecoveryJournalSnapshot {
+    try {
+      this.storage().removeItem(this.storageKey);
+      return this.snapshot([], [issue]);
+    } catch {
+      return this.snapshot([], [issue, "denied"]);
+    }
+  }
+  private persist(
+    entries: ReadonlyArray<RecoveryJournalEntry>,
+    issues: ReadonlyArray<RecoveryJournalIssue>,
+  ): RecoveryJournalSnapshot {
+    const record: RecoveryJournalRecord = {
+      formatVersion: 1,
+      appId: this.options.appId,
+      sessionEpoch: this.options.sessionEpoch,
+      clientSessionId: this.clientSessionId,
+      entries,
+    };
+    const encoded = Schema.encodeOption(Schema.fromJsonString(RecoveryJournalRecord))(record);
+    if (encoded._tag === "None") return this.snapshot(entries, [...issues, "corrupt"]);
+    if (bytes(encoded.value) > RecoveryJournalLimits.maxBytes)
+      return this.snapshot(entries, [...issues, "full"]);
+    try {
+      this.storage().setItem(this.storageKey, encoded.value);
+      return this.snapshot(entries, issues);
+    } catch (error) {
+      return this.snapshot(entries, [
+        ...issues,
+        error instanceof DOMException && error.name === "QuotaExceededError" ? "full" : "denied",
+      ]);
+    }
+  }
+  /** Call before abandoning the page; any issue means durable recovery is not proven. */
+  write(identities: ReadonlyArray<RecoveryIdentity>): RecoveryJournalSnapshot {
+    const current = this.read();
+    if (current.issues.includes("denied")) return current;
+    const entries = new Map(current.entries.map((entry) => [identityKey(entry.identity), entry]));
+    const now = this.now();
+    for (const identity of identities) {
+      if (identity.originalSelection.appId !== this.options.appId)
+        return this.snapshot(current.entries, [...current.issues, "corrupt"]);
+      const key = identityKey(identity);
+      if (!entries.has(key))
+        entries.set(key, {
+          identity: {
+            invocationId: identity.invocationId,
+            originalSelection: identity.originalSelection,
+          },
+          recordedAt: now,
+          expiresAt: now + RecoveryJournalLimits.retentionMs,
+          state: "pending",
+        });
+    }
+    if (entries.size > RecoveryJournalLimits.maxEntries)
+      return this.snapshot(current.entries, [...current.issues, "full"]);
+    return this.persist([...entries.values()], current.issues);
+  }
+  reconcile(
+    identity: RecoveryIdentity,
+    state: Exclude<RecoveryJournalEntry["state"], "pending">,
+  ): RecoveryJournalSnapshot {
+    const current = this.read();
+    if (current.issues.includes("denied")) return current;
+    return this.persist(
+      current.entries.map((entry) =>
+        identityKey(entry.identity) === identityKey(identity) ? { ...entry, state } : entry,
+      ),
+      current.issues,
+    );
+  }
+  remove(identity: RecoveryIdentity): RecoveryJournalSnapshot {
+    const current = this.read();
+    if (current.issues.includes("denied")) return current;
+    return this.persist(
+      current.entries.filter((entry) => identityKey(entry.identity) !== identityKey(identity)),
+      current.issues,
+    );
+  }
+  clear(): RecoveryJournalSnapshot {
+    try {
+      this.storage().removeItem(this.storageKey);
+      return this.snapshot([], []);
+    } catch {
+      return this.snapshot([], ["denied"]);
+    }
+  }
+}

package/src/client/route-boundaries.ts

@@ -0,0 +1,184 @@
+import { createElement as h, Fragment, type ComponentChildren, type ComponentType } from "preact";
+import { useErrorBoundary, useState } from "preact/hooks";
+import type {
+  ErrorBoundaryProps,
+  LoadedBranch,
+  RouterSnapshot,
+  RouterStore,
+} from "./router-store.js";
+import type { RouteLocation } from "./routes.js";
+
+export const DefaultError = ({ error, retry }: ErrorBoundaryProps): ComponentChildren =>
+  h(
+    "div",
+    { role: "alert" },
+    error instanceof Error ? error.message : "This page could not load or render. ",
+    h("button", { onClick: retry }, "Retry"),
+  );
+
+interface BoundaryProps {
+  readonly children: ComponentChildren;
+  readonly component: ComponentType<ErrorBoundaryProps>;
+  readonly branch: LoadedBranch;
+  readonly router: RouterStore;
+  readonly onRetry?: () => void;
+}
+const Boundary = ({
+  children,
+  component,
+  branch,
+  router,
+  onRetry,
+}: BoundaryProps): ComponentChildren => {
+  const [failure, setFailure] = useState<{
+    readonly branch: LoadedBranch;
+    readonly error: unknown;
+  }>();
+  const [, reset] = useErrorBoundary((error) => {
+    setFailure({ branch, error });
+    router.setRenderError(true);
+  });
+  return failure?.branch !== branch
+    ? children
+    : h(component, {
+        error: failure.error,
+        retry: () => {
+          router.setRenderError(false);
+          onRetry?.();
+          setFailure(undefined);
+          reset();
+        },
+      });
+};
+
+export const Branch = ({
+  branch,
+  location,
+  router,
+  failure,
+}: {
+  readonly branch: LoadedBranch;
+  readonly location: RouteLocation;
+  readonly router: RouterStore;
+  readonly failure: RouterSnapshot["failure"];
+}): ComponentChildren => {
+  const outcome = branch.outcome;
+  let child: ComponentChildren;
+  let lastLayout = branch.layouts.length - 1;
+  let boundaryOwner: number | undefined;
+  if (outcome._tag === "Matched" && branch.page !== undefined) {
+    child = h(branch.page, {
+      key: outcome.route.id,
+      params: outcome.params,
+      searchParams: outcome.searchParams,
+    });
+  } else if (outcome._tag === "Invalid" && branch.pageBoundaries?.invalid !== undefined) {
+    child = h(branch.pageBoundaries.invalid, { location, issues: outcome.issues });
+  } else {
+    child = h(
+      "main",
+      { "data-ignotum-outcome": outcome._tag },
+      outcome._tag === "Invalid" ? "Invalid URL" : "Page not found",
+    );
+    for (let index = lastLayout; index >= 0; index--) {
+      const layout = branch.layouts[index]!;
+      if (outcome._tag === "Invalid" && layout.invalid !== undefined) {
+        child = h(layout.invalid, { location, issues: outcome.issues });
+        lastLayout = index;
+        boundaryOwner = index;
+        break;
+      }
+      if (outcome._tag === "NotFound" && layout.notFound !== undefined) {
+        child = h(layout.notFound, { location });
+        lastLayout = index;
+        boundaryOwner = index;
+        break;
+      }
+    }
+  }
+  if (branch.pageBoundaries?.error !== undefined && outcome._tag === "Matched")
+    child = h(Boundary, {
+      key: "page-boundary",
+      component: branch.pageBoundaries.error,
+      branch,
+      router,
+      children: child,
+    });
+  let sharedLayouts = 0;
+  while (
+    sharedLayouts <= lastLayout &&
+    branch.layouts[sharedLayouts]?.id === failure?.branch?.layouts[sharedLayouts]?.id
+  )
+    sharedLayouts++;
+  const loadFailure =
+    failure === undefined
+      ? null
+      : h(LoadFailure, {
+          failure,
+          router,
+          layouts: branch.layouts.slice(0, sharedLayouts),
+        });
+  for (let index = lastLayout; index >= 0; index--) {
+    const layout = branch.layouts[index]!;
+    if (layout.error !== undefined && index !== boundaryOwner)
+      child = h(Boundary, {
+        key: layout.id,
+        component: layout.error,
+        branch,
+        router,
+        children: child,
+      });
+    child = h(layout.component, {
+      key: layout.id,
+      children: h(Fragment, {}, child, index === sharedLayouts - 1 ? loadFailure : null),
+    });
+  }
+  return h(Boundary, {
+    component: DefaultError,
+    branch,
+    router,
+    children: h(Fragment, {}, child, sharedLayouts === 0 ? loadFailure : null),
+  });
+};
+
+export const LoadFailure = ({
+  failure,
+  router,
+  layouts,
+}: {
+  readonly failure: NonNullable<RouterSnapshot["failure"]>;
+  readonly layouts?: LoadedBranch["layouts"];
+  readonly router: RouterStore;
+}): ComponentChildren => {
+  const branch = failure.branch;
+  if (branch === undefined)
+    return h("div", { "data-ignotum-load-error": "" }, h(DefaultError, failure));
+  let child: ComponentChildren = h(DefaultError, failure);
+  let found = false;
+  for (const layout of [...(layouts ?? branch.layouts)].reverse()) {
+    if (layout.error === undefined) continue;
+    if (!found) {
+      child = h(layout.error, { error: failure.error, retry: failure.retry });
+      found = true;
+    } else {
+      child = h(Boundary, {
+        component: layout.error,
+        branch,
+        router,
+        onRetry: failure.retry,
+        children: child,
+      });
+    }
+  }
+  return h(
+    "div",
+    { "data-ignotum-load-error": "" },
+    h(Boundary, {
+      component: DefaultError,
+      branch,
+      router,
+      onRetry: failure.retry,
+      children: child,
+    }),
+  );
+};