@almadar/shell-runtime 0.0.0-stage → 0.1.0

package/dist/chunk-ELBLT2HZ.js

@@ -0,0 +1 @@
+

package/dist/chunk-EV56K4GB.js

@@ -0,0 +1,63 @@
+// src/runtime/effects/composition/layout-strategy.ts
+function hasSequentialChain(wiring) {
+  if (wiring.length < 2) {
+    return false;
+  }
+  const adjacency = /* @__PURE__ */ new Map();
+  const allTargets = /* @__PURE__ */ new Set();
+  for (const entry of wiring) {
+    let targets = adjacency.get(entry.from);
+    if (!targets) {
+      targets = /* @__PURE__ */ new Set();
+      adjacency.set(entry.from, targets);
+    }
+    targets.add(entry.to);
+    allTargets.add(entry.to);
+  }
+  const roots = [];
+  for (const from of adjacency.keys()) {
+    if (!allTargets.has(from)) {
+      roots.push(from);
+    }
+  }
+  const starts = roots.length > 0 ? roots : [...adjacency.keys()];
+  for (const start of starts) {
+    let current = start;
+    let length = 1;
+    const visited = /* @__PURE__ */ new Set([current]);
+    while (true) {
+      const nexts = adjacency.get(current);
+      if (!nexts || nexts.size === 0) break;
+      let advanced = false;
+      for (const next of nexts) {
+        if (!visited.has(next)) {
+          visited.add(next);
+          current = next;
+          length++;
+          advanced = true;
+          break;
+        }
+      }
+      if (!advanced) break;
+    }
+    if (length >= 3) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectLayoutStrategy(orbitals, eventWiring) {
+  if (eventWiring && eventWiring.length > 0 && hasSequentialChain(eventWiring)) {
+    return "wizard-flow";
+  }
+  const count = orbitals.length;
+  if (count <= 1) {
+    return "single";
+  }
+  if (count <= 4) {
+    return "tabs";
+  }
+  return "sidebar";
+}
+
+export { detectLayoutStrategy };

package/dist/chunk-EZZYLTWY.js

@@ -0,0 +1 @@
+

package/dist/chunk-FQ6IZMIU.js

@@ -0,0 +1,10 @@
+// src/runtime/effects/composition/pipe.ts
+function pipeBehaviors(seed, ...steps) {
+  let current = seed;
+  for (const step of steps) {
+    current = step(current);
+  }
+  return current;
+}
+
+export { pipeBehaviors };

package/dist/chunk-FWA5K7Q2.js

@@ -0,0 +1,48 @@
+// src/effects/on-device-model.ts
+var NO_ON_DEVICE_MODEL = "browser/prompt: no on-device model is wired into this host";
+var NO_ON_DEVICE_EMBEDDER = "browser/embed: no on-device embedder is wired into this host";
+var OnDeviceModelFailure = class extends Error {
+  kind;
+  payload;
+  constructor(kind, message, key) {
+    super(message);
+    this.name = "OnDeviceModelFailure";
+    this.kind = kind;
+    this.payload = { error: message, kind, key };
+  }
+};
+function failureMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function promptOnDevice(ports, text, schemaText, key, signal) {
+  const model = ports?.model;
+  if (model === void 0) throw new OnDeviceModelFailure("unconfigured", NO_ON_DEVICE_MODEL, key);
+  let schema;
+  try {
+    const parsed = JSON.parse(schemaText);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("not an object");
+    schema = parsed;
+  } catch {
+    throw new OnDeviceModelFailure("failed", "browser/prompt: the response schema must be JSON Schema text: a JSON object", key);
+  }
+  try {
+    const state = await model.availability();
+    if (state !== "available") throw new OnDeviceModelFailure("unavailable", `The on-device model is ${state}`, key);
+    return await model.prompt(text, schema, signal);
+  } catch (error) {
+    if (error instanceof OnDeviceModelFailure) throw error;
+    throw new OnDeviceModelFailure("failed", failureMessage(error), key);
+  }
+}
+async function embedOnDevice(ports, texts, key, signal) {
+  if (texts.length === 0) return [];
+  const embedder = ports?.embedder;
+  if (embedder === void 0) throw new OnDeviceModelFailure("unconfigured", NO_ON_DEVICE_EMBEDDER, key);
+  try {
+    return await embedder.embed([...texts], signal);
+  } catch (error) {
+    throw new OnDeviceModelFailure("failed", failureMessage(error), key);
+  }
+}
+
+export { NO_ON_DEVICE_EMBEDDER, NO_ON_DEVICE_MODEL, OnDeviceModelFailure, embedOnDevice, promptOnDevice };

package/dist/chunk-HC6ERSAH.js

@@ -0,0 +1,55 @@
+// src/client/awaiting.ts
+var AwaitingRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  anyListeners = /* @__PURE__ */ new Set();
+  version = 0;
+  begin(list) {
+    for (const entry of list) {
+      this.entries.set(entry.trait, entry);
+      this.emit(entry.trait);
+    }
+  }
+  end(traits) {
+    for (const trait of traits) {
+      if (!this.entries.delete(trait)) continue;
+      this.emit(trait);
+    }
+  }
+  get(trait) {
+    return this.entries.get(trait);
+  }
+  list() {
+    return [...this.entries.values()];
+  }
+  subscribe(trait, listener) {
+    let set = this.listeners.get(trait);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(trait, set);
+    }
+    set.add(listener);
+    return () => {
+      set?.delete(listener);
+      if (set && set.size === 0) this.listeners.delete(trait);
+    };
+  }
+  /** Any trait's awaiting change (an empty slot does not know which trait will fill it). */
+  subscribeAll(listener) {
+    this.anyListeners.add(listener);
+    return () => {
+      this.anyListeners.delete(listener);
+    };
+  }
+  /** Bumped on every change — a stable snapshot key for `useSyncExternalStore`. */
+  getVersion() {
+    return this.version;
+  }
+  emit(trait) {
+    this.version += 1;
+    this.listeners.get(trait)?.forEach((listener) => listener());
+    this.anyListeners.forEach((listener) => listener());
+  }
+};
+
+export { AwaitingRegistry };

package/dist/chunk-HLOUDLPI.js

@@ -0,0 +1,48 @@
+// src/credentials/scope.ts
+function credentialModeFromEnv(env) {
+  return env.ALMADAR_INTEGRATIONS_MODE === "mock" || env.USE_MOCK_DATA === "true" ? "mock" : "real";
+}
+var installedStore = null;
+var modeControl = null;
+var tenantScope;
+function installCredentialScopeStorage(storage) {
+  tenantScope = storage;
+}
+function runWithCredentialScope(store, fn) {
+  if (tenantScope === void 0) throw new Error("runWithCredentialScope needs an installed CredentialScopeStorage (a Node host installs it through @almadar/shell-node)");
+  return tenantScope.run(store, fn);
+}
+function installModeControl(control) {
+  modeControl = control;
+}
+function getModeControl() {
+  return modeControl;
+}
+function installCredentialStore(store) {
+  installedStore = store;
+}
+function getInstalledCredentialStore() {
+  return installedStore;
+}
+function getEffectiveCredentialStore() {
+  return tenantScope?.getStore() ?? installedStore;
+}
+function uninstallCredentialStore() {
+  installedStore = null;
+}
+var CREDENTIALS_SOURCE_ENV = "ALMADAR_CREDENTIALS_SOURCE";
+var HOST_SETTING_VARS = /* @__PURE__ */ new Set(["ALMADAR_CREDENTIAL_ADMIN_ROLES", CREDENTIALS_SOURCE_ENV, "ALMADAR_INTEGRATIONS_MODE", "USE_MOCK_DATA"]);
+function credentialsFromStoreOnly(env) {
+  return env[CREDENTIALS_SOURCE_ENV] === "store";
+}
+function resolveCredentialRef(ref, env = typeof process === "undefined" ? {} : process.env, principal) {
+  const tenant = tenantScope?.getStore();
+  if (tenant) return tenant.resolve(ref, principal);
+  if (principal !== void 0) return installedStore?.resolve(ref, principal);
+  const stored = installedStore?.resolve(ref);
+  if (stored !== void 0) return stored;
+  if (credentialsFromStoreOnly(env) && !HOST_SETTING_VARS.has(ref)) return void 0;
+  return env[ref];
+}
+
+export { CREDENTIALS_SOURCE_ENV, credentialModeFromEnv, credentialsFromStoreOnly, getEffectiveCredentialStore, getInstalledCredentialStore, getModeControl, installCredentialScopeStorage, installCredentialStore, installModeControl, resolveCredentialRef, runWithCredentialScope, uninstallCredentialStore };

package/dist/chunk-HMK6YMQS.js

@@ -0,0 +1,135 @@
+import { eventPayloadOf, isInlineTrait, normalizeCallSiteConfigToValues, JsonValueSchema, isJsonObject, EntityRowSchema, orbitalInlineEntities } from '@almadar/core';
+import { ownerFieldsFromSchema } from '@almadar/core/mock';
+
+// src/runtime/entities/std-mock-seed.ts
+var SEED_ORBITAL = "MockSeedOrbital";
+var SEED_TRAIT = "MockSeed";
+function asJson(value) {
+  return JsonValueSchema.parse(JSON.parse(JSON.stringify(value)));
+}
+function fieldOf(value, name, what) {
+  if (value === void 0 || !isJsonObject(value)) throw new Error(`std-mock-seed: ${what} is not an object`);
+  const found = value[name];
+  if (found === void 0) throw new Error(`std-mock-seed: ${what} has no ${name}`);
+  return found;
+}
+function textOf(value, what) {
+  if (typeof value !== "string") throw new Error(`std-mock-seed: ${what} is not a string`);
+  return value;
+}
+function cellOf(value) {
+  return {
+    store: textOf(fieldOf(value, "store", "owner cell"), "cell store"),
+    id: textOf(fieldOf(value, "id", "owner cell"), "cell id"),
+    column: textOf(fieldOf(value, "column", "owner cell"), "cell column")
+  };
+}
+function cellsOf(value, what) {
+  if (!Array.isArray(value)) throw new Error(`std-mock-seed: ${what} is not an array`);
+  return value.map(cellOf);
+}
+function journalOf(value) {
+  return {
+    viewerId: textOf(fieldOf(value, "viewerId", "journal"), "journal viewerId"),
+    stamped: cellsOf(fieldOf(value, "stamped", "journal"), "journal stamped"),
+    deferred: cellsOf(fieldOf(value, "deferred", "journal"), "journal deferred")
+  };
+}
+function changeOf(value) {
+  const kind = fieldOf(value, "kind", "owner change");
+  if (kind !== "set" && kind !== "rekey") throw new Error("std-mock-seed: owner change kind is neither set nor rekey");
+  return { ...cellOf(value), kind, ownerId: textOf(fieldOf(value, "ownerId", "owner change"), "change ownerId") };
+}
+function storesOf(value) {
+  if (!isJsonObject(value)) throw new Error("std-mock-seed: dataset stores is not an object");
+  return Object.fromEntries(Object.entries(value).map(([store, rows]) => [store, EntityRowSchema.array().parse(rows)]));
+}
+function ownerPairsOf(schema) {
+  return ownerFieldsFromSchema(schema).map((field) => {
+    const dot = field.indexOf(".");
+    if (dot <= 0 || dot === field.length - 1) throw new Error(`std-mock-seed: owner field ${field} is not Entity.column`);
+    return { entity: field.slice(0, dot), column: field.slice(dot + 1) };
+  });
+}
+var StdMockSeed = class {
+  constructor(engine, config, user) {
+    this.engine = engine;
+    this.config = config;
+    this.user = user;
+  }
+  engine;
+  config;
+  user;
+  async ask(event, payload, done) {
+    const response = await this.engine.evaluate(
+      SEED_ORBITAL,
+      { event, targetTrait: SEED_TRAIT, payload: eventPayloadOf(asJson(payload)) },
+      { orbital: SEED_ORBITAL, ...this.user !== void 0 ? { user: this.user } : {} }
+    );
+    const failed = response.emittedEvents.find((emitted) => emitted.event === "DATASET_FAILED");
+    if (failed !== void 0) throw new Error(`std-mock-seed: ${event} refused: ${JSON.stringify(failed.payload ?? {})}`);
+    const answer = response.emittedEvents.find((emitted) => emitted.event === done);
+    if (answer === void 0) throw new Error(`std-mock-seed: ${event} did not answer ${done}`);
+    return asJson(answer.payload ?? {});
+  }
+  /** Sample the program's dataset (`DATASET_INPUT`). */
+  async dataset(program, run) {
+    const done = await this.ask("DATASET_INPUT", {
+      program,
+      count: this.config.count,
+      seed: this.config.seed,
+      nowMs: run.nowMs,
+      viewerId: run.viewerId ?? "",
+      ownerPairs: ownerPairsOf(program),
+      ...run.locale !== void 0 ? { locale: run.locale } : {}
+    }, "DATASET_DONE");
+    return { stores: storesOf(fieldOf(done, "stores", "DATASET_DONE")), journal: journalOf(fieldOf(done, "journal", "DATASET_DONE")) };
+  }
+  /**
+   * Re-point the dataset's tracked owner cells at `viewer` (`RESTAMP_INPUT`); `stores` are the current authoritative rows.
+   * `firstOwner` marks the stamp right after seeding; a persona switch restamps only when the program's
+   * `restampOnPersona` config says so, otherwise it answers no changes.
+   */
+  async restamp(program, stores, journal, viewer, firstOwner) {
+    const done = await this.ask("RESTAMP_INPUT", { program, stores, journal, viewer, firstOwner, restampOnPersona: this.config.restampOnPersona }, "RESTAMP_DONE");
+    const changes = fieldOf(done, "changes", "RESTAMP_DONE");
+    if (!Array.isArray(changes)) throw new Error("std-mock-seed: RESTAMP_DONE changes is not an array");
+    return { journal: journalOf(fieldOf(done, "journal", "RESTAMP_DONE")), changes: changes.map(changeOf) };
+  }
+};
+var STD_MOCK_SEED_SOURCE = "std/behaviors/std-mock-seed";
+var SEED_TRAIT_REF = "traits.MockSeed";
+function declaredValue(values, key, is) {
+  const value = values[key];
+  if (value === void 0 || !is(value)) throw new Error(`std-mock-seed: config ${key} is not declared as expected`);
+  return value;
+}
+function declaredSeedConfig(seedProgram, app) {
+  const seedTrait = seedProgram.orbitals.flatMap((orbital) => orbital.traits ?? []).find((t) => isInlineTrait(t) && t.name === SEED_TRAIT);
+  if (seedTrait === void 0 || !isInlineTrait(seedTrait)) throw new Error(`std-mock-seed: the seed program has no ${SEED_TRAIT} trait`);
+  const composed = (app?.orbitals ?? []).flatMap((orbital) => {
+    const aliases = (orbital.uses ?? []).filter((u) => u.from === STD_MOCK_SEED_SOURCE).map((u) => u.as);
+    return (orbital.traits ?? []).flatMap((t) => typeof t !== "string" && !isInlineTrait(t) && aliases.some((alias) => t.ref === `${alias}.${SEED_TRAIT_REF}`) ? [normalizeCallSiteConfigToValues(t.config) ?? {}] : []);
+  });
+  const values = Object.assign({}, normalizeCallSiteConfigToValues(seedTrait.config) ?? {}, ...composed);
+  return {
+    count: declaredValue(values, "count", (v) => typeof v === "number"),
+    seed: declaredValue(values, "seed", (v) => typeof v === "number"),
+    defaultPersona: declaredValue(values, "defaultPersona", (v) => typeof v === "string"),
+    restampOnPersona: declaredValue(values, "restampOnPersona", (v) => typeof v === "boolean")
+  };
+}
+function entityByStore(program) {
+  const byStore = /* @__PURE__ */ new Map();
+  for (const entity of program.orbitals.flatMap(orbitalInlineEntities)) {
+    if (entity.collection !== void 0 && entity.collection !== "") byStore.set(entity.collection, entity.name);
+  }
+  return byStore;
+}
+async function readSeededStores(persistence, program) {
+  const stores = {};
+  for (const [store, entityType] of entityByStore(program)) stores[store] = await persistence.list(entityType);
+  return stores;
+}
+
+export { StdMockSeed, declaredSeedConfig, readSeededStores };

package/dist/chunk-HNOAZWFH.js

@@ -0,0 +1,19 @@
+// src/kernel/program-effects.ts
+var PROGRAM_EFFECTS = [
+  "behavior/catalog",
+  "behavior/describe",
+  "behavior/source",
+  "behavior/resolve",
+  "behavior/dependencies",
+  "program/read",
+  "program/print",
+  "program/eval",
+  "program/validate",
+  "program/compose",
+  "program/step"
+];
+function isProgramEffect(name) {
+  return PROGRAM_EFFECTS.includes(name);
+}
+
+export { PROGRAM_EFFECTS, isProgramEffect };

package/dist/chunk-IHQLE5M7.js

@@ -0,0 +1,62 @@
+// src/runtime/events/identity/routing.ts
+function eventRouteKey(eventName, eventId) {
+  return eventId ? `@evt:${eventId}` : eventName;
+}
+function buildSourceMatcher(src, listenerOrbital) {
+  if (src.kind === "any") return () => true;
+  if (src.kind === "trait") {
+    if (src.traitId !== void 0) {
+      const wantedTraitId = src.traitId;
+      return (source) => !!source && source.traitId === wantedTraitId;
+    }
+    const wantedTrait2 = src.trait;
+    return (source) => !!source && source.orbital === listenerOrbital && source.trait === wantedTrait2;
+  }
+  if (src.orbitalId !== void 0 && src.traitId !== void 0) {
+    const wantedOrbitalId = src.orbitalId;
+    const wantedTraitId = src.traitId;
+    return (source) => !!source && source.orbitalId === wantedOrbitalId && source.traitId === wantedTraitId;
+  }
+  const wantedOrbital = src.orbital;
+  const wantedTrait = src.trait;
+  return (source) => !!source && source.orbital === wantedOrbital && source.trait === wantedTrait;
+}
+function parseListenSource(listener, listenerOrbital) {
+  const explicit = listener.source;
+  if (explicit && typeof explicit === "object") {
+    return {
+      bareEvent: listener.event,
+      matcher: buildSourceMatcher(explicit, listenerOrbital)
+    };
+  }
+  const key = listener.event;
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    return { bareEvent: key, matcher: () => true };
+  }
+  if (parts.length === 2) {
+    const [sourceOrStar, eventName] = parts;
+    if (sourceOrStar === "*") {
+      return { bareEvent: eventName, matcher: () => true };
+    }
+    return {
+      bareEvent: eventName,
+      matcher: buildSourceMatcher(
+        { kind: "trait", trait: sourceOrStar },
+        listenerOrbital
+      )
+    };
+  }
+  if (parts.length >= 3) {
+    const eventName = parts[parts.length - 1];
+    const trait = parts[parts.length - 2];
+    const orbital = parts.slice(0, parts.length - 2).join(".");
+    return {
+      bareEvent: eventName,
+      matcher: buildSourceMatcher({ kind: "orbital", orbital, trait }, listenerOrbital)
+    };
+  }
+  return { bareEvent: key, matcher: () => true };
+}
+
+export { buildSourceMatcher, eventRouteKey, parseListenSource };

package/dist/chunk-IOPUS6Q5.js

@@ -0,0 +1,15 @@
+// src/client/trait-mount-error.ts
+var TraitMountError = class extends Error {
+  trait;
+  event;
+  original;
+  constructor(trait, event, original) {
+    super(original.message);
+    this.name = "TraitMountError";
+    this.trait = trait;
+    this.event = event;
+    this.original = original;
+  }
+};
+
+export { TraitMountError };

package/dist/chunk-JFWFDUTR.js

@@ -0,0 +1,35 @@
+import { readSeededStores } from './chunk-HMK6YMQS.js';
+import { orbitalInlineEntities, personaFromIdentityRow } from '@almadar/core';
+import { identityEntitiesOf } from '@almadar/core/mock';
+import { createLogger } from '@almadar/logger';
+
+var log = createLogger("almadar:shell-web:mock-seed");
+function bindDeclaredCollections(store, entities) {
+  for (const entity of entities) {
+    if (entity.name && entity.collection && entity.browser !== true && entity.persistence !== "runtime") {
+      store.bindCollection?.(entity.name, entity.collection);
+    }
+  }
+}
+async function seedMockStore(host, schema, viewer) {
+  bindDeclaredCollections(host.persistence, schema.orbitals.flatMap(orbitalInlineEntities));
+  const named = viewer.namedByHost ? viewer.current() : void 0;
+  const dataset = await host.seeder.dataset(schema, { nowMs: host.nowMs, ...named !== void 0 ? { viewerId: named.id } : {} });
+  if (viewer.namedByHost) return { viewer: named, journal: dataset.journal };
+  const declared = host.seeder.config.defaultPersona;
+  if (declared === "") return { viewer: void 0, journal: dataset.journal };
+  const identity = identityEntitiesOf(schema.orbitals)[0];
+  const row = identity?.collection !== void 0 ? (dataset.stores[identity.collection] ?? []).find((r) => r.id === declared) : void 0;
+  const resolved = row === void 0 ? void 0 : personaFromIdentityRow(row);
+  if (resolved === void 0) throw new Error(`std-mock-seed: defaultPersona ${declared} names no ${identity?.name ?? "identity"} row of the seeded dataset`);
+  const restamp = await host.seeder.restamp(schema, dataset.stores, dataset.journal, resolved, true);
+  log.debug("seeded", { identity: identity?.name, viewer: resolved.id, changes: restamp.changes.length });
+  return { viewer: resolved, journal: restamp.journal };
+}
+async function restampMockOwner(host, schema, journal, user) {
+  const stores = await readSeededStores(host.persistence, schema);
+  const restamp = await host.seeder.restamp(schema, stores, journal, user, false);
+  return restamp.journal;
+}
+
+export { bindDeclaredCollections, restampMockOwner, seedMockStore };

package/dist/chunk-LZIOTBFX.js

@@ -0,0 +1 @@
+

package/dist/chunk-MHYSHSRG.js

@@ -0,0 +1,54 @@
+import { isInlineTrait } from '@almadar/core';
+
+// src/runtime/effects/composition/event-wiring.ts
+function findInlineTrait(orbitals, name) {
+  for (const orbital of orbitals) {
+    for (const traitRef of orbital.traits) {
+      if (isInlineTrait(traitRef) && traitRef.name === name) {
+        return traitRef;
+      }
+    }
+  }
+  return null;
+}
+function hasEmit(emits, event) {
+  return emits.some((e) => e.event === event);
+}
+function hasListen(listens, event, triggers) {
+  return listens.some((l) => l.event === event && l.triggers === triggers);
+}
+function applyEventWiring(orbitals, wiring) {
+  const cloned = JSON.parse(
+    JSON.stringify(orbitals)
+  );
+  for (const entry of wiring) {
+    const sourceTrait = findInlineTrait(cloned, entry.from);
+    if (sourceTrait) {
+      if (!sourceTrait.emits) {
+        sourceTrait.emits = [];
+      }
+      if (!hasEmit(sourceTrait.emits, entry.event)) {
+        sourceTrait.emits.push({
+          event: entry.event,
+          scope: "external"
+        });
+      }
+    }
+    const targetTrait = findInlineTrait(cloned, entry.to);
+    if (targetTrait) {
+      if (!targetTrait.listens) {
+        targetTrait.listens = [];
+      }
+      if (!hasListen(targetTrait.listens, entry.event, entry.triggers)) {
+        targetTrait.listens.push({
+          event: entry.event,
+          triggers: entry.triggers,
+          scope: "external"
+        });
+      }
+    }
+  }
+  return cloned;
+}
+
+export { applyEventWiring };

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export { __export };

package/dist/chunk-MZKIL5IN.js

@@ -0,0 +1,74 @@
+// src/effects/in-flight-calls.ts
+var InFlightCalls = class {
+  calls = /* @__PURE__ */ new Map();
+  /** Whether a call started with `key` is still running. */
+  inFlight(key) {
+    return (this.calls.get(key)?.size ?? 0) > 0;
+  }
+  /**
+   * Run `work` registered under `key`, handing it the abort signal; `work` must settle promptly once the
+   * signal aborts (see `untilAborted`). The call is cancelled when the signal was aborted by the time
+   * `work` settles, whatever it settled with.
+   */
+  async run(key, work) {
+    const lease = this.track(key);
+    try {
+      const value = await work(lease.signal);
+      return lease.signal.aborted ? { cancelled: true } : { cancelled: false, value };
+    } catch (err) {
+      if (lease.signal.aborted) return { cancelled: true };
+      throw err;
+    } finally {
+      lease.release();
+    }
+  }
+  reserve(key) {
+    return this.inFlight(key) ? void 0 : this.track(key);
+  }
+  track(key) {
+    const controller = new AbortController();
+    const running = this.calls.get(key) ?? /* @__PURE__ */ new Set();
+    running.add(controller);
+    this.calls.set(key, running);
+    return {
+      signal: controller.signal,
+      release: () => {
+        running.delete(controller);
+        if (running.size === 0 && this.calls.get(key) === running) this.calls.delete(key);
+      }
+    };
+  }
+  cancelAll() {
+    for (const key of this.calls.keys()) this.cancel(key);
+  }
+  /** Abort every call running under `key`; false (a no-op) when none is. */
+  cancel(key) {
+    const running = this.calls.get(key);
+    if (running === void 0 || running.size === 0) return false;
+    this.calls.delete(key);
+    for (const controller of running) controller.abort();
+    return true;
+  }
+};
+function untilAborted(signal, promise) {
+  if (signal.aborted) {
+    promise.catch(() => void 0);
+    return Promise.reject(new Error("The call was cancelled"));
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(new Error("The call was cancelled"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (err) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(err);
+      }
+    );
+  });
+}
+
+export { InFlightCalls, untilAborted };