@wssto2/vue-core 0.8.0 → 0.9.1

package/dist/application-DtY0ef-w.js

@@ -0,0 +1,420 @@
+var Me = Object.defineProperty;
+var Le = (e, n, o) => n in e ? Me(e, n, { enumerable: !0, configurable: !0, writable: !0, value: o }) : e[n] = o;
+var ee = (e, n, o) => Le(e, typeof n != "symbol" ? n + "" : n, o);
+import { effectScope as W, watch as B, defineComponent as me, openBlock as je, createElementBlock as Ae, createVNode as te, unref as K, withCtx as se, createTextVNode as Ne, toDisplayString as Ke, shallowRef as Oe, computed as _e, h as oe, createApp as Ce } from "vue";
+import { useI18n as Fe, createI18n as Ie } from "vue-i18n";
+import { createRouter as Te, isNavigationFailure as qe } from "vue-router";
+import { i as De } from "./leaveGuard-Cc8yeLxM.js";
+import { c as Pe, i as We, f as Be } from "./format-Dn-BOb-o.js";
+import { coreMessages as re, createMessageRuntime as He } from "./i18n/index.js";
+import { i as Ve, a as Ge } from "./Icon.vue_vue_type_script_lang-BhhsFYwp.js";
+import { i as Je, b as ze } from "./bottomDock-BZEiOPYZ.js";
+import { i as Qe, p as Ue } from "./chrome-nUcmVu8G.js";
+import { i as Xe, g as Ye } from "./platform-BZUWAXQV.js";
+import { c as Ze, A as et, r as ae } from "./access-DmAceEo5.js";
+import { c as tt, _ as st } from "./NoAccess.vue_vue_type_script_setup_true_lang-BHzZtZ50.js";
+import { i as ot } from "./guards-Cz7TOQD8.js";
+import { b as rt, c as at, n as ne } from "./navigation-CWj6F_cV.js";
+import { c as nt, s as ie } from "./contributions-DGsAIWd8.js";
+import { a as ce } from "./environment-Dva-SG8D.js";
+import { b as le, c as ue } from "./describeError-BqGAUZgX.js";
+import { _ as it } from "./Button.vue_vue_type_script_setup_true_lang-Dn-cJcj3.js";
+import { _ as ct } from "./EmptyState.vue_vue_type_script_setup_true_lang-DbZiO2RF.js";
+import { i as lt } from "./feature-DdUAfyi4.js";
+function ut(e) {
+  const { platform: n } = e, o = W();
+  let c = null, v = null, y = !1;
+  function E(l, m) {
+    const h = new AbortController(), f = { controller: h, stops: [] };
+    for (const k of l)
+      try {
+        const b = m(k, h.signal);
+        typeof b == "function" && f.stops.push({ owned: k, stop: b });
+      } catch (b) {
+        e.onError(b, k);
+      }
+    return f;
+  }
+  function R(l) {
+    if (l) {
+      l.controller.abort();
+      for (const { owned: m, stop: h } of l.stops.reverse())
+        try {
+          h();
+        } catch (f) {
+          e.onError(f, m);
+        }
+    }
+  }
+  const M = (l) => e.effects.filter((m) => m.effect.scope === l), x = (l) => l.status !== "authenticated" ? null : e.sessionKey ? e.sessionKey(l) : String(l.user.id);
+  return {
+    start() {
+      if (y || c) return;
+      c = E(
+        M("app"),
+        (m, h) => m.effect.start({ signal: h, platform: n, report: (f) => e.onError(f, m) })
+      );
+      const l = M("session");
+      o.run(
+        () => B(
+          () => x(n.session.state.value),
+          (m) => {
+            R(v), v = null;
+            const h = n.session.state.value;
+            m === null || h.status !== "authenticated" || (v = E(
+              l,
+              (f, k) => f.effect.start({ signal: k, platform: n, user: h.user, report: (b) => e.onError(b, f) })
+            ));
+          },
+          { immediate: !0, flush: "sync" }
+        )
+      );
+    },
+    dispose() {
+      y || (y = !0, o.stop(), R(v), R(c), v = c = null);
+    }
+  };
+}
+const ft = { class: "mx-auto flex min-h-screen max-w-content items-center justify-center p-screen-padding" }, dt = /* @__PURE__ */ me({
+  __name: "StartupFailure",
+  props: {
+    kind: {}
+  },
+  emits: ["retry"],
+  setup(e) {
+    const { t: n } = Fe();
+    return (o, c) => (je(), Ae("div", ft, [
+      te(K(ct), {
+        title: K(n)("core.startup.title"),
+        description: K(n)(e.kind === "startup" ? "core.startup.other" : `core.startup.${e.kind}`),
+        icon: "errorWarningLine"
+      }, {
+        actions: se(() => [
+          te(K(it), {
+            prominence: "primary",
+            icon: "refreshLine",
+            onClick: c[0] || (c[0] = (v) => o.$emit("retry"))
+          }, {
+            default: se(() => [
+              Ne(Ke(K(n)("core.actions.retry")), 1)
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["title", "description"])
+    ]));
+  }
+});
+class fe extends Error {
+  constructor(o) {
+    super(`The application composition is invalid:
+${o.map((c) => `  - [${c.owner}] ${c.message}`).join(`
+`)}`);
+    ee(this, "issues");
+    this.name = "ApplicationError", this.issues = o;
+  }
+}
+const de = "application", w = (e) => `feature "${e.id}"`;
+function* H(e, n = "") {
+  for (const o of e) {
+    const c = o.path.startsWith("/") ? o.path : `${n.replace(/\/$/, "")}/${o.path}`;
+    yield { record: o, path: c }, o.children && (yield* H(o.children, c));
+  }
+}
+function pt(e) {
+  const n = [], o = (s, r) => n.push({ owner: s, message: r }), c = [];
+  e.features.forEach((s, r) => {
+    lt(s) ? c.push(s) : o(de, `features[${r}] was not created with defineFeature().`);
+  });
+  const v = /* @__PURE__ */ new Map();
+  for (const s of c)
+    v.has(s.id) ? o(w(s), `the feature id "${s.id}" is used twice in the features list.`) : v.set(s.id, s);
+  for (const s of c)
+    for (const r of s.requires)
+      v.has(r) || o(w(s), `requires the feature "${r}", which is not in the features list.`);
+  const y = [], E = /* @__PURE__ */ new Set(), R = (s) => {
+    if (E.has(s.id)) return;
+    const r = y.indexOf(s.id);
+    if (r !== -1) {
+      o(w(s), `requirements form a cycle: ${[...y.slice(r), s.id].join(" -> ")}.`), E.add(s.id);
+      return;
+    }
+    y.push(s.id);
+    for (const u of s.requires) {
+      const i = v.get(u);
+      i && R(i);
+    }
+    y.pop(), E.add(s.id);
+  };
+  c.forEach(R);
+  const M = new Set(e.platform.config.capabilities);
+  for (const s of c)
+    for (const r of s.backend)
+      M.has(r) || o(w(s), `needs the backend capability "${r}", which the server does not report.`);
+  const x = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
+  for (const s of c) {
+    for (const r of s.routes) {
+      const u = r.path.length > 1 ? r.path.replace(/\/$/, "") : r.path, i = l.get(u);
+      i ? o(w(s), `declares the path "${r.path}", which feature "${i.id}" declares too.`) : l.set(u, s);
+    }
+    for (const { record: r } of H(s.routes)) {
+      if (r.meta && "feature" in r.meta && o(w(s), `the route "${String(r.name ?? r.path)}" sets meta.feature, which the runtime owns.`), typeof r.name != "string") continue;
+      const u = x.get(r.name);
+      u ? o(w(s), `declares the route name "${r.name}", which feature "${u.id}" declares too.`) : x.set(r.name, s);
+    }
+  }
+  const m = new Set(e.reservedContexts), h = /* @__PURE__ */ new Map();
+  for (const s of c)
+    for (const { key: r } of s.contexts) {
+      const u = r.description ?? "a context";
+      m.has(r) && o(w(s), `provides the context "${u}", which the runtime provides itself.`);
+      const i = h.get(r);
+      i ? o(w(s), `provides the context "${u}", which feature "${i.id}" provides too.`) : h.set(r, s);
+    }
+  const f = /* @__PURE__ */ new Map(), k = (s, r) => {
+    for (const u of r) {
+      const i = f.get(u.namespace);
+      i ? o(s, `declares the message namespace "${u.namespace}", which ${i} declares too.`) : f.set(u.namespace, s);
+      for (const L of Object.keys(u.loaders))
+        e.supportedLocales.includes(L) || o(s, `the namespace "${u.namespace}" has a loader for "${L}", which is not a supported locale (${e.supportedLocales.join(", ")}).`);
+    }
+  };
+  for (const s of c) k(w(s), s.messages);
+  k(de, e.messages);
+  const b = (s) => f.has(s);
+  for (const s of c)
+    for (const { record: r } of H(s.routes))
+      for (const u of r.meta?.messages ?? [])
+        b(u) || o(w(s), `the route "${String(r.name ?? r.path)}" needs the message namespace "${u}", which nobody declares.`);
+  const O = /* @__PURE__ */ new Map();
+  for (const s of c)
+    for (const r of s.contributions) {
+      const u = O.get(r.id);
+      u ? o(w(s), `declares the shell contribution "${r.id}", which feature "${u.id}" declares too.`) : O.set(r.id, s), e.shellSlots && !r.optional && !e.shellSlots.includes(r.slot) && o(w(s), `contributes "${r.id}" to the slot "${r.slot}", which the shell does not render (it renders ${e.shellSlots.join(", ") || "none"}). Mark it optional to leave it out instead.`);
+      for (const i of r.messages ?? [])
+        b(i) || o(w(s), `the contribution "${r.id}" needs the message namespace "${i}", which nobody declares.`);
+    }
+  const _ = /* @__PURE__ */ new Map();
+  for (const s of c)
+    for (const r of s.effects) {
+      const u = _.get(r.id);
+      u ? o(w(s), `declares the effect "${r.id}", which feature "${u.id}" declares too.`) : _.set(r.id, s);
+      const i = r.scope;
+      i !== "app" && i !== "session" && o(w(s), `the effect "${r.id}" has the scope "${i}"; use "app" or "session".`);
+    }
+  return { features: c, issues: n };
+}
+const mt = (e, n, o) => Ie({
+  legacy: !1,
+  locale: e,
+  fallbackLocale: n,
+  pluralRules: o?.pluralRules && { ...o.pluralRules },
+  ...o?.missingWarn === !1 && { missingWarn: !1, fallbackWarn: !1 },
+  messages: {}
+}), ht = (e) => typeof e == "object" && e !== null && "component" in e && "slots" in e;
+function he(e, n) {
+  return e.map((o) => ({
+    ...o,
+    meta: { ...o.meta, feature: n },
+    ...o.children && { children: he(o.children, n) }
+  }));
+}
+const pe = (e) => [...new Set(e)];
+function Dt(e) {
+  const { platform: n } = e, o = e.locale?.supported ?? Object.keys(re), c = e.locale?.fallback ?? "en", v = e.shell === void 0 ? void 0 : ht(e.shell) ? e.shell : { component: e.shell, slots: void 0, progress: void 0 }, y = [];
+  o.includes(c) || y.push({ owner: "application", message: `the fallback locale "${c}" is not among the supported locales (${o.join(", ")}).` });
+  for (const t of Object.keys(e.locale?.flags ?? {}))
+    o.includes(t) || y.push({ owner: "application", message: `locale.flags names the locale "${t}", which is not among the supported locales (${o.join(", ")}).` });
+  const E = e.locale?.initial ?? (o.includes(n.config.locale) ? n.config.locale : c);
+  o.includes(E) || y.push({ owner: "application", message: `the initial locale "${E}" is not among the supported locales (${o.join(", ")}).` });
+  const R = [Ye, Be, Ue, ze, Ge, ne, ie, ae, ce, le, ue], M = pt({
+    features: e.features,
+    platform: n,
+    messages: e.messages ?? [],
+    reservedContexts: R,
+    supportedLocales: o,
+    shellSlots: v?.slots
+  }), x = [...y, ...M.issues], l = M.features, m = rt(
+    l.flatMap((t) => t.navigation.map((a) => ({ feature: t.id, binding: a }))),
+    e.navigation
+  );
+  for (const t of m.issues) x.push({ owner: "navigation", message: t });
+  if (x.length > 0) throw new fe(x);
+  const h = mt(E, c, e.i18n), f = h.global;
+  for (const [t, a] of Object.entries(re)) f.mergeLocaleMessage(t, a);
+  for (const [t, a] of Object.entries(e.i18n?.messages ?? {})) f.mergeLocaleMessage(t, a);
+  const { currencySymbol: k, ...b } = e.formatting ?? {}, O = Pe({ locale: () => f.locale.value, formatters: b, currencySymbol: k }), _ = [...l.flatMap((t) => t.messages), ...e.messages ?? []], s = (t) => (e.onError ?? gt)({ ...t, route: i.currentRoute.value.matched.length > 0 ? i.currentRoute.value.fullPath : null }), r = He({
+    target: f,
+    namespaces: _,
+    fallback: c,
+    supported: o,
+    onFailure: (t) => s({ source: "messages", error: t.error, detail: `${t.namespace} (${t.locale})`, feature: u.get(t.namespace) })
+  }), u = new Map(l.flatMap((t) => t.messages.map((a) => [a.namespace, t.id]))), i = Te({
+    history: e.router?.history ?? tt(),
+    routes: l.flatMap((t) => he(t.routes, t.id)),
+    scrollBehavior: e.router?.scrollBehavior ?? ((t, a) => t.name === a.name ? !1 : { top: 0 })
+  }), L = e.router?.login ?? { name: "login" }, ge = e.router?.home ?? { path: "/" }, C = [], V = (t) => {
+    try {
+      return i.resolve(t).matched.length > 0 ? null : "matches no route";
+    } catch (a) {
+      const p = a instanceof Error ? a.message : String(a);
+      return p.startsWith("No match for") ? "matches no route" : `cannot be resolved (${p})`;
+    }
+  };
+  if (l.some((t) => t.routes.some((a) => a.meta?.public !== !0))) {
+    const t = V(L) ?? (i.resolve(L).meta.public === !0 ? null : "is not public (meta.public: true)");
+    t && C.push({ owner: "application", message: `the login route ${JSON.stringify(L)} ${t.replace("matches no route", "does not exist")}, but protected routes are installed: an anonymous visitor would have nowhere to go. Install a feature with the login route or set router.login.` });
+  }
+  for (const { feature: t, binding: a } of m.destinations.values()) {
+    const p = V(a.to);
+    p && C.push({ owner: `feature "${t}"`, message: `the destination "${a.destination}" is bound to ${JSON.stringify(a.to)}, which ${p}.` });
+  }
+  if (C.length > 0) throw new fe(C);
+  const j = Oe({ status: "idle" }), F = {
+    state: j,
+    locale: _e(() => f.locale.value),
+    locales: o,
+    localeFlags: e.locale?.flags ?? {},
+    setLocale: async (t) => {
+      const a = f.locale.value, p = await r.setLocale(t);
+      if (p && f.locale.value !== a) {
+        const g = (N) => s({ source: "locale", error: N, detail: t });
+        try {
+          Promise.resolve(e.locale?.onChange?.(t)).catch(g);
+        } catch (N) {
+          g(N);
+        }
+      }
+      return p;
+    },
+    retry: () => P()
+  }, T = {
+    contributions: l.flatMap((t) => t.contributions.map((a) => ({ feature: t.id, contribution: a }))),
+    effects: l.flatMap((t) => t.effects.map((a) => ({ feature: t.id, effect: a })))
+  }, G = ut({
+    effects: T.effects,
+    platform: n,
+    sessionKey: e.sessionKey,
+    onError: (t, a) => s({ source: "effect", error: t, feature: a.feature, detail: a.effect.id })
+  }), we = new Map(l.map((t) => [t.id, t.messages.map((a) => a.namespace)])), J = (t) => pe(T.contributions.filter(({ contribution: a }) => a.scope === t).flatMap(({ contribution: a }) => a.messages ?? [])), ve = J("always"), ye = J("authenticated");
+  async function $e(t) {
+    const a = t.matched.flatMap((g) => [...we.get(g.meta.feature ?? "") ?? [], ...g.meta.messages ?? []]), p = n.session.state.value.status === "authenticated";
+    await r.load(pe([...a, ...ve, ...p ? ye : []]));
+  }
+  let q = null;
+  function D(t) {
+    const a = t.meta.titleKey, p = q?.documentTitle.value ?? (a && f.te(a) ? f.t(a) : null), g = (e.router?.documentTitle ?? wt)(p, n.config.appName);
+    g !== "" && (document.title = g);
+  }
+  const be = at({ session: n.session, router: i, i18n: f, destinations: m.destinations }), Ee = nt(T.contributions, n.session), ke = Ze({ router: i, access: n.access, noAccess: e.noAccess ?? st }), Se = me({
+    name: "ApplicationRoot",
+    setup() {
+      return () => {
+        const t = j.value;
+        return t.status === "failed" ? oe(dt, { kind: t.kind, onRetry: () => void P() }) : t.status !== "ready" ? null : oe(v?.component ?? et);
+      };
+    }
+  }), d = Ce(Se);
+  Xe(d, n), d.use(h), We(d, O), q = Qe(d), Je(d), De(d), e.icons && Ve(d, ...Array.isArray(e.icons) ? e.icons : [e.icons]), d.provide(ce, F), e.describeError && d.provide(le, e.describeError), e.describeFieldError && d.provide(ue, e.describeFieldError), d.provide(ne, be), d.provide(ie, Ee), d.provide(ae, ke);
+  for (const t of l) for (const { key: a, value: p } of t.contexts) d.provide(a, p);
+  let S = !1, z = !1, Q = !1, U = !1;
+  const A = [];
+  function Re() {
+    const t = d.config.errorHandler;
+    d.config.errorHandler = ($, xe, Z) => {
+      s({ source: "vue", error: $, detail: Z }), t?.($, xe, Z);
+    };
+    const a = ($) => s({ source: "unhandledrejection", error: $.reason }), p = ($) => {
+      $.error && s({ source: "window", error: $.error });
+    };
+    window.addEventListener("unhandledrejection", a), window.addEventListener("error", p), A.push(() => {
+      window.removeEventListener("unhandledrejection", a), window.removeEventListener("error", p);
+    });
+    const g = l.some(($) => $.holdsExpiredSession);
+    n.session.holdExpired(g), A.push(() => n.session.holdExpired(!1)), A.push(
+      ot({
+        router: i,
+        session: n.session,
+        login: L,
+        home: ge,
+        holdExpired: g,
+        prepare: $e,
+        afterNavigation: D,
+        progress: e.router?.progress ?? v?.progress,
+        onError: ($) => s({ source: "router", error: $ })
+      })
+    );
+    const N = W();
+    N.run(() => B(() => q?.documentTitle.value, () => D(i.currentRoute.value))), A.push(() => N.stop());
+    const Y = W();
+    Y.run(
+      () => B(
+        () => f.locale.value,
+        ($) => {
+          document.documentElement.lang = $, D(i.currentRoute.value);
+        },
+        { immediate: !0 }
+      )
+    ), A.push(() => Y.stop());
+  }
+  const I = (t, a) => {
+    j.value = { status: "failed", kind: t, error: a };
+  };
+  async function X() {
+    j.value = { status: "starting" };
+    const t = await n.session.restore();
+    if (S) return;
+    if (t.status === "failed") return I("session", t.error);
+    const a = t.status === "authenticated" ? t.user.locale : void 0;
+    if (typeof a == "string" && a !== f.locale.value && o.includes(a) && await F.setLocale(a), S) return;
+    const p = await r.loadEssential();
+    if (!S) {
+      if (p.length > 0) return I("messages", p[0].error);
+      try {
+        const g = await i.replace(i.options.history.location);
+        if (S) return;
+        if (qe(g)) return I("startup", g);
+      } catch (g) {
+        S || I("startup", g);
+        return;
+      }
+      U || (d.use(i), U = !0), j.value = { status: "ready" }, G.start();
+    }
+  }
+  async function P() {
+    S || j.value.status !== "failed" || (await r.retry(), await X());
+  }
+  return {
+    app: d,
+    router: i,
+    i18n: h,
+    state: j,
+    locale: F.locale,
+    setLocale: F.setLocale,
+    async mount(t) {
+      if (S) throw new Error("This application was disposed; create a new one with createApplication().");
+      if (z) throw new Error("This application is already mounted.");
+      z = !0, Re(), await X(), !S && (d.mount(t), Q = !0);
+    },
+    retry: P,
+    dispose() {
+      if (!S) {
+        S = !0, G.dispose(), r.dispose(), Q && d.unmount();
+        for (const t of A.reverse()) t();
+        i.options.history.destroy();
+      }
+    }
+  };
+}
+function gt(e) {
+  console.error(`[vue-core] ${e.source}${e.feature ? ` (${e.feature})` : ""}${e.detail ? `: ${e.detail}` : ""}`, e.error);
+}
+function wt(e, n) {
+  return [e, n].filter((o) => !!o).join(" · ");
+}
+export {
+  fe as A,
+  Dt as c,
+  gt as d
+};

package/dist/button/index.js

@@ -1,4 +1,4 @@
-import { _ as a, m as o, s as r, u, a as e } from "../Button.vue_vue_type_script_setup_true_lang-DQq_0P0p.js";
+import { _ as a, m as o, s as r, u, a as e } from "../Button.vue_vue_type_script_setup_true_lang-Dn-cJcj3.js";
 export {
   a as Button,
   o as matchesShortcut,

package/dist/button/shortcut.d.ts

@@ -1,6 +1,8 @@
 import { type ComputedRef, type MaybeRefOrGetter } from "vue";
 /**
  * A keyboard shortcut: the key (case-insensitive, as `KeyboardEvent.key`) and exactly the modifiers listed.
+ * A symbol key (`/`, `?`, one character that is no letter, digit or space) matches whatever the Shift state is
+ * unless `shiftKey` is set, because on many layouts the symbol itself needs Shift (Shift+7 is `/` on a Croatian keyboard).
  * With a `label` it is listed by `useShortcutRegistry()` (a help dialog) for as long as its owner is mounted.
  */
 export interface KeyboardShortcut {
@@ -9,6 +11,11 @@ export interface KeyboardShortcut {
     shiftKey?: boolean;
     altKey?: boolean;
     metaKey?: boolean;
+    /**
+     * The platform's command modifier: Ctrl or ⌘ alone (one of the two, with `shiftKey`/`altKey` as set), on every platform,
+     * so a Mac keyboard on a Windows browser still works; listed as ⌘ on Apple platforms and Ctrl elsewhere. Replaces `ctrlKey` and `metaKey`.
+     */
+    mod?: boolean;
     /** What it does, in the app's language ("Search the list"); a function is read when the list is read, so it follows the locale. An empty text is not listed. */
     label?: string | (() => string);
     /** The heading it is listed under; any name the app has a heading for. The library's own use `"list"` and `"record"`. */

package/dist/client/client.d.ts

@@ -11,6 +11,25 @@ export interface RequestOptions {
     /** False for calls that establish or end the session (sign-in, `/auth/me`), where a 401 is an answer, not an expiry. Default true. */
     handleUnauthorized?: boolean;
 }
+/**
+ * Options of `download` and `stream`: those of the JSON calls plus the `Accept` header (default: any type) and, for
+ * `POST`, a body encoded like the body of `post`. A body without `method: "POST"` does not compile.
+ */
+export type RawRequestOptions = RequestOptions & {
+    accept?: string;
+} & ({
+    method?: "GET";
+    body?: undefined;
+} | {
+    method: "POST";
+    body?: unknown;
+});
+/** A file the server answered: the bytes, the name its `Content-Disposition` proposes (RFC 6266; null when it proposes none) and the exchange's request id. */
+export interface DownloadResult {
+    blob: Blob;
+    filename: string | null;
+    requestId: string | null;
+}
 /** What `onUnauthorized` decides: send the request once more (the session was renewed) or let the 401 fail. */
 export type UnauthorizedDecision = "retry" | "fail";
 export interface UnauthorizedContext {
@@ -52,6 +71,20 @@ export interface HttpClient {
     put<TData = unknown, TMeta = unknown>(path: string, body?: unknown, options?: RequestOptions): Promise<ApiResult<TData, TMeta>>;
     patch<TData = unknown, TMeta = unknown>(path: string, body?: unknown, options?: RequestOptions): Promise<ApiResult<TData, TMeta>>;
     delete<TData = unknown, TMeta = unknown>(path: string, options?: RequestOptions): Promise<ApiResult<TData, TMeta>>;
+    /**
+     * Fetches a file. Base URL, credentials, `headers()`, `X-Request-ID`, abort and the single 401 renew-and-retry are those of
+     * `get`; `Accept` accepts any type unless `options.accept` says otherwise. A non-2xx answer throws the same `ApiError` a JSON call
+     * would (its `code`, `fields` and `params` come from the JSON error body), so the caller words a failed download like any failure.
+     * The whole body is read before this resolves.
+     */
+    download(path: string, options?: RawRequestOptions): Promise<DownloadResult>;
+    /**
+     * Opens a long-lived answer (server-sent events, a streamed file) and resolves with the raw `Response` as soon as its headers
+     * are in, body unread: read `response.body`, and pass `options.signal` to end it. Headers, credentials, request id and the 401
+     * retry are those of `download`; a non-2xx answer throws an `ApiError`. Once it has resolved, a read that fails or is cancelled
+     * rejects with the platform's own error, not an `ApiError`.
+     */
+    stream(path: string, options?: RawRequestOptions): Promise<Response>;
     /**
      * The `X-Request-ID`s of the last requests this client got an answer to or failed to reach (the server's id, else the one sent),
      * oldest first, at most `RECENT_REQUEST_IDS`: what a bug report quotes so the server's log can be found. A cancelled request leaves none.

package/dist/client/disposition.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The file name of a `Content-Disposition` header (RFC 6266): `filename*=` (RFC 8187, UTF-8 or ISO-8859-1) wins over
+ * `filename=`, quotes and backslash escapes are handled, a directory part is dropped. Null when the header has no usable name.
+ */
+export declare function filenameFromDisposition(header: string | null): string | null;

package/dist/client/index.d.ts

@@ -1,5 +1,5 @@
 export { createHttpClient, RECENT_REQUEST_IDS } from "./client";
-export type { HttpClient, RouteResult, HttpClientOptions, RequestOptions, UnauthorizedContext, UnauthorizedDecision } from "./client";
+export type { HttpClient, RouteResult, HttpClientOptions, RequestOptions, RawRequestOptions, DownloadResult, UnauthorizedContext, UnauthorizedDecision } from "./client";
 export type { QueryValue } from "./encode";
 export { REQUEST_ID_HEADER } from "./envelope";
 export type { ApiResult } from "./envelope";

package/dist/client/index.js

@@ -1,4 +1,4 @@
-import { R as p, a as o, c as u, f as E } from "../client-CZgikXPG.js";
+import { R as p, a as o, c as u, f as E } from "../client-Dr2vV3qH.js";
 import { A as n, a as f, i as l } from "../error-Bb_dr_Ay.js";
 function s(e, i, r = {}) {
   return { method: e, path: i, permission: r.permission, public: r.public === !0, raw: !1 };