@paradow/ledge 0.28.0 → 0.29.0-snapshot.41297455946.1

package/dist/cli/{chunk-RYZ6FHYT.js → chunk-UMQGRTA4.js}

@@ -1,31 +1,23 @@
 import {
-  EFFORT_ARGS,
-  MODEL_ARGS
-} from "./chunk-OYDTU6AP.js";
+  realTmux
+} from "./chunk-KBSXP63H.js";
 import {
-  findRole
-} from "./chunk-JHFKBKSO.js";
+  log
+} from "./chunk-G3ST5WKR.js";
 import {
   exitFile,
   spawnSession
-} from "./chunk-LG3XFIPV.js";
+} from "./chunk-O4MUYFPH.js";
 import {
   DaemonRefusedError,
   connect
-} from "./chunk-VMGACWNP.js";
+} from "./chunk-FWLT3SAN.js";
 import {
-  PROTOCOL_PORT,
-  autonomyArgs
-} from "./chunk-VKRFHDRK.js";
-import {
-  realTmux
-} from "./chunk-NLL2EQJ2.js";
-import {
-  log
-} from "./chunk-6IYPRUQG.js";
+  PROTOCOL_PORT
+} from "./chunk-2X56ZRK7.js";
 import {
   ensureLedgeDir
-} from "./chunk-HOOHS3MX.js";
+} from "./chunk-W724IVDC.js";
 
 // src/cli/launch.ts
 import { spawn } from "child_process";
@@ -36,30 +28,19 @@ var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 function parseLaunchArgs(argv) {
   const args = [];
   let name;
-  let role;
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--name") {
       name = argv[++i];
       continue;
     }
-    if (a === "--role") {
-      role = argv[++i];
-      continue;
-    }
     if (a === "--") {
       args.push(...argv.slice(i + 1));
       break;
     }
     args.push(a);
   }
-  return { name, ...role ? { role } : {}, args };
-}
-function roleArgs(tool, role, args) {
-  const own = role.tool === void 0 || role.tool === tool;
-  const hasModel = args.some((a) => a === "--model" || a === "-m" || a.startsWith("--model="));
-  const hasEffort = args.some((a) => a === "--effort" || a.startsWith("--effort=") || a.includes("model_reasoning_effort"));
-  return [...own && role.model && !hasModel ? MODEL_ARGS[tool](role.model) : [], ...own && role.effort && !hasEffort ? EFFORT_ARGS[tool]?.(role.effort) ?? [] : [], ...autonomyArgs(tool, role.autonomy)];
+  return { name, args };
 }
 function portOpen(port) {
   return new Promise((res) => {
@@ -137,8 +118,7 @@ async function createSession(opts) {
       ids.push(s.id);
     }
   }
-  const { role, ...rest } = opts;
-  const session = await spawnSession({ ...rest, ...role ? { args: [...roleArgs(opts.tool, role, opts.args), ...opts.args], role: { id: role.id, label: role.label }, ...role.autonomy ? { autonomy: role.autonomy } : {} } : {}, taken: { names, ids } });
+  const session = await spawnSession({ ...opts, taken: { names, ids } });
   try {
     opts.client?.send({ type: "session.register", session });
   } catch (e) {
@@ -175,21 +155,20 @@ var UNTRACKED = {
   unreachable: () => "ledge: daemon not running, session not tracked"
 };
 async function launch(tool, argv, opts = {}) {
+  if (argv.some((a) => a === "--role" || a.startsWith("--role="))) {
+    console.error("--role a \xE9t\xE9 retir\xE9 (les \xE9quipes et r\xF4les de Ledge n'existent plus)");
+    return 1;
+  }
   await ensureLedgeDir();
-  const { name, role: roleId, args } = parseLaunchArgs(argv);
+  const { name, args } = parseLaunchArgs(argv);
   const port = opts.port ?? PROTOCOL_PORT;
   const socket = opts.tmuxSocket ?? TMUX_SOCKET;
   const tmux = realTmux(socket);
   const cwd = opts.cwd ?? process.cwd();
-  const role = roleId ? findRole(roleId, cwd) : void 0;
-  if (roleId && !role) {
-    console.error(`ledge: r\xF4le inconnu : ${roleId} (aucun fichier .ledge/roles/${roleId}.md ni ~/.ledge/roles/${roleId}.md)`);
-    return 1;
-  }
   const daemon = await ensureDaemon({ port, spawnDaemon: opts.spawnDaemon, retryDelayMs: opts.retryDelayMs });
   let client = daemon.client;
   if (!daemon.client) console.error(UNTRACKED[daemon.reason](port));
-  const create = (c) => createSession({ tool, args, command: opts.command, recordExit: true, name, ...role ? { role } : {}, cwd, tmux, client: c });
+  const create = (c) => createSession({ tool, args, command: opts.command, recordExit: true, name, cwd, tmux, client: c });
   let session;
   try {
     session = await create(client);
@@ -223,7 +202,6 @@ async function launch(tool, argv, opts = {}) {
 
 export {
   parseLaunchArgs,
-  roleArgs,
   ensureDaemon,
   DaemonError,
   createSession,

package/dist/cli/{chunk-3CF4FQWG.js → chunk-VQR5ME75.js}

@@ -1,10 +1,10 @@
 import {
   CODEX_HOOK_VAR
-} from "./chunk-LG3XFIPV.js";
+} from "./chunk-O4MUYFPH.js";
 import {
   connect,
   sendMessageAndAwaitAck
-} from "./chunk-VMGACWNP.js";
+} from "./chunk-FWLT3SAN.js";
 
 // src/cli/send.ts
 import { randomUUID } from "crypto";
@@ -130,8 +130,9 @@ function parseLedgeCommand(command) {
   if (words[1] === "who" && words.length === 2) return { cmd: "who" };
   if (words[1] === "send") return { cmd: "send", args: words.slice(2) };
   if (words[1] === "read") return { cmd: "read", args: words.slice(2) };
-  if (words[1] === "task") return { cmd: "task", args: words.slice(2) };
+  if (words[1] === "ask") return { cmd: "ask", args: words.slice(2) };
   if (words[1] === "handover") return { cmd: "handover", args: words.slice(2) };
+  if (words[1] === "brain") return { cmd: "brain", args: words.slice(2) };
   return void 0;
 }
 

package/dist/cli/{chunk-HOOHS3MX.js → chunk-W724IVDC.js}

@@ -17,7 +17,7 @@ function ledgeDir() {
 }
 function paths() {
   const dir = ledgeDir();
-  return { dir, tmuxConf: join(dir, "tmux.conf"), journal: join(dir, "sessions.json"), log: join(dir, "daemon.log"), pid: join(dir, "daemon.pid"), history: join(dir, "history"), mail: join(dir, "mail.json"), tasks: join(dir, "tasks.json"), teams: join(dir, "teams-live.json"), machines: join(dir, "machines.json"), projects: join(dir, "projects.json"), island: join(dir, "island.json"), token: join(dir, "token"), mobile: join(dir, "mobile.json"), mobileSession: join(dir, "mobile-session.json"), mobileKey: join(dir, "mobile-key"), devices: join(dir, "devices.json"), revocations: join(dir, "revocations.json"), attachments: join(dir, "attachments") };
+  return { dir, tmuxConf: join(dir, "tmux.conf"), journal: join(dir, "sessions.json"), log: join(dir, "daemon.log"), pid: join(dir, "daemon.pid"), history: join(dir, "history"), mail: join(dir, "mail.json"), asks: join(dir, "asks.json"), machines: join(dir, "machines.json"), projects: join(dir, "projects.json"), island: join(dir, "island.json"), token: join(dir, "token"), mobile: join(dir, "mobile.json"), mobileSession: join(dir, "mobile-session.json"), mobileKey: join(dir, "mobile-key"), devices: join(dir, "devices.json"), revocations: join(dir, "revocations.json"), attachments: join(dir, "attachments"), openrig: join(dir, "openrig.json"), ledgeThread: join(dir, "ledge-thread.jsonl"), rigs: join(dir, "rigs"), rigLaunches: join(dir, "rig-launches.json"), mandate: join(dir, "mandat.md"), memoryDir: join(dir, "memoire"), rules: join(dir, "memoire", "rules.json"), decisions: join(dir, "memoire", "decisions.jsonl"), brainSettings: join(dir, "brain.json"), brainDir: join(dir, "brain") };
 }
 async function ensureLedgeDir() {
   const p = paths();

package/dist/cli/{chunk-K7UEKSB2.js → chunk-WYRQZA4G.js}

@@ -1,10 +1,10 @@
 import {
   run
-} from "./chunk-NLL2EQJ2.js";
+} from "./chunk-KBSXP63H.js";
 import {
   ensureLedgeDir,
   paths
-} from "./chunk-HOOHS3MX.js";
+} from "./chunk-W724IVDC.js";
 
 // src/cli/setup.ts
 import { readFile as readFile2, writeFile, mkdir, rename, realpath, rm, stat, lstat, readlink } from "fs/promises";

package/dist/cli/chunk-XTDE2URL.js

@@ -0,0 +1,365 @@
+import {
+  PROJECT_COLORS,
+  RIG_NAME,
+  parseServerMessage
+} from "./chunk-2X56ZRK7.js";
+
+// src/imageInfo.ts
+var ok = (mime, width, height) => width > 0 && height > 0 ? { mime, width, height } : null;
+function jpeg(b) {
+  let i = 2;
+  while (i + 4 <= b.length) {
+    if (b[i] !== 255) {
+      i++;
+      continue;
+    }
+    const m = b[i + 1];
+    if (m === 255) {
+      i++;
+      continue;
+    }
+    if (m === 216 || m === 1 || m >= 208 && m <= 215) {
+      i += 2;
+      continue;
+    }
+    const len = b.readUInt16BE(i + 2);
+    if (m >= 192 && m <= 207 && m !== 196 && m !== 200 && m !== 204) return i + 9 <= b.length ? ok("image/jpeg", b.readUInt16BE(i + 7), b.readUInt16BE(i + 5)) : null;
+    i += 2 + len;
+  }
+  return null;
+}
+function webp(b) {
+  const kind = b.toString("latin1", 12, 16);
+  if (kind === "VP8X") return b.length >= 30 ? ok("image/webp", b.readUIntLE(24, 3) + 1, b.readUIntLE(27, 3) + 1) : null;
+  if (kind === "VP8L") {
+    if (b.length < 25 || b[20] !== 47) return null;
+    const bits = b.readUInt32LE(21);
+    return ok("image/webp", (bits & 16383) + 1, (bits >>> 14 & 16383) + 1);
+  }
+  if (kind === "VP8 ") return b.length >= 30 && b[23] === 157 && b[24] === 1 && b[25] === 42 ? ok("image/webp", b.readUInt16LE(26) & 16383, b.readUInt16LE(28) & 16383) : null;
+  return null;
+}
+function imageInfo(b) {
+  try {
+    if (b.length >= 24 && b.readUInt32BE(0) === 2303741511 && b.readUInt32BE(4) === 218765834 && b.toString("latin1", 12, 16) === "IHDR") return ok("image/png", b.readUInt32BE(16), b.readUInt32BE(20));
+    if (b.length >= 10 && (b.toString("latin1", 0, 6) === "GIF87a" || b.toString("latin1", 0, 6) === "GIF89a")) return ok("image/gif", b.readUInt16LE(6), b.readUInt16LE(8));
+    if (b.length >= 4 && b[0] === 255 && b[1] === 216) return jpeg(b);
+    if (b.length >= 16 && b.toString("latin1", 0, 4) === "RIFF" && b.toString("latin1", 8, 12) === "WEBP") return webp(b);
+  } catch {
+  }
+  return null;
+}
+
+// ../ui/src/rigs/model.ts
+var rigKey = (r) => `${r.machine}/${r.id}`;
+var COLOR_NAMES = Object.keys(PROJECT_COLORS);
+function rigColor(r) {
+  let sum = 0;
+  for (let i = 0; i < r.name.length; i++) sum += r.name.charCodeAt(i);
+  return COLOR_NAMES[sum % COLOR_NAMES.length];
+}
+function kernelSplit(rig) {
+  const hidden = [], shown = [];
+  for (const s of rig.seats) (s.name.startsWith("advisor") || s.runtime === "terminal" ? hidden : shown).push(s);
+  return { shown, hidden };
+}
+var workingCount = (rig) => rig.seats.filter((s) => s.state === "working").length;
+function rigPlace(rig, projects) {
+  if (rig.projectId) return { kind: "project", name: projects?.projects.find((p) => p.id === rig.projectId)?.name ?? rig.projectId };
+  if (rig.offProject) return { kind: "off", cwd: rig.cwd };
+  return { kind: "none" };
+}
+function isStandalone(s, rigs) {
+  if (s.brain) return false;
+  const r = s.rig;
+  if (!r) return true;
+  return !rigs.some((x) => x.machine === r.machine && x.seats.some((seat) => seat.sessionId === s.id && seat.state !== "stopped"));
+}
+var MENTION_RIG = /* @__PURE__ */ new Set(["running", "partial"]);
+var MENTION_DOWN = /* @__PURE__ */ new Set(["stopped", "crashed", "attention"]);
+function seatMentions(rigs, query) {
+  const live = rigs.filter((r) => r.machine === "local" && MENTION_RIG.has(r.lifecycle)).flatMap((rig) => rig.seats.filter((s) => !MENTION_DOWN.has(s.state)).map((seat) => ({ rig, seat })));
+  const holders = /* @__PURE__ */ new Map();
+  for (const { seat } of live) holders.set(seat.address, (holders.get(seat.address) ?? 0) + 1);
+  const q = query.toLowerCase();
+  return live.filter(({ rig, seat }) => !rig.kernel && seat.address.replace(/^@/, "").toLowerCase().startsWith(q)).sort((a, b) => a.seat.address.localeCompare(b.seat.address) || a.rig.name.localeCompare(b.rig.name)).map(({ rig, seat }) => {
+    const shared = (holders.get(seat.address) ?? 0) > 1;
+    const insert = shared ? `${seat.address}@${rig.name}` : seat.address;
+    return { key: `${rigKey(rig)}/${seat.ref}`, label: shared ? insert : `${seat.address} \xB7 ${rig.name}`, insert };
+  });
+}
+function ledgeLine(escalations, rigs, said) {
+  const open = escalations.filter((e) => e.intent === "decision" && (e.state === "pending" || e.state === "grace")).sort((a, b) => a.createdAt < b.createdAt ? -1 : a.createdAt > b.createdAt ? 1 : 0);
+  const rigOf = (e) => {
+    const name = e?.rigId ? rigs.find((r) => r.machine === e.machine && r.id === e.rigId)?.name : void 0;
+    return name ? { rig: name } : {};
+  };
+  const pending = open.filter((e) => e.state === "pending");
+  if (pending.length) return { preview: { kind: "decision", count: pending.length, ...rigOf(pending[0]) }, at: pending[0].createdAt, unread: open.length };
+  const grace = open[0];
+  if (grace) return { preview: { kind: "grace", ...rigOf(grace) }, at: grace.createdAt, unread: open.length };
+  if (said) return { preview: { kind: "said", text: said.text }, at: said.at, unread: 0 };
+  return { preview: { kind: "calm", rigs: rigs.filter((r) => !r.kernel).length }, unread: 0 };
+}
+function shortCwd(cwd) {
+  const m = /^(\/home\/[^/]+|\/root)(?=\/|$)/.exec(cwd);
+  return m ? `~${cwd.slice(m[0].length)}` : cwd;
+}
+var RUNTIME_LABELS = { "claude-code": "Claude Code", codex: "Codex" };
+var runtimeLabel = (runtime) => RUNTIME_LABELS[runtime] ?? runtime;
+
+// ../fleet/src/token.ts
+import { useSyncExternalStore } from "react";
+var DAEMON_PROTOCOL_PREFIX = "ledge.";
+var READ_TIMEOUT_MS = 1e4;
+function createTokenSource(read) {
+  let cached = null, missing = false, inflight = null;
+  const fns = /* @__PURE__ */ new Set();
+  const setMissing = (m) => {
+    if (m !== missing) {
+      missing = m;
+      fns.forEach((f) => f(m));
+    }
+  };
+  const load = async () => {
+    let r, timer;
+    const unavailable = { kind: "unavailable" };
+    try {
+      const got = await Promise.race([read(), new Promise((res) => {
+        timer = setTimeout(() => res(unavailable), READ_TIMEOUT_MS);
+      })]);
+      r = got?.kind === "token" && typeof got.token === "string" || got?.kind === "absent" ? got : unavailable;
+    } catch {
+      r = unavailable;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (r.kind === "token") cached = r.token;
+    else if (r.kind === "absent") cached = null;
+    setMissing(r.kind === "absent");
+    return r;
+  };
+  return {
+    get(fresh) {
+      if (!fresh && cached !== null) return Promise.resolve({ kind: "token", token: cached });
+      inflight ??= load().finally(() => {
+        inflight = null;
+      });
+      return inflight;
+    },
+    missing: () => missing,
+    onMissing(fn) {
+      fns.add(fn);
+      return () => {
+        fns.delete(fn);
+      };
+    }
+  };
+}
+
+// ../fleet/src/client.ts
+function createDaemonClient(opts) {
+  const Ws = opts.WebSocketImpl ?? globalThis.WebSocket;
+  const min = opts.minBackoffMs ?? 2e3, max = opts.maxBackoffMs ?? 3e4, token = opts.token;
+  let ws = null, status = "connecting", backoff = min, timer = null, closed = false;
+  let failed = false;
+  let attempt = 0;
+  const msgFns = /* @__PURE__ */ new Set(), statusFns = /* @__PURE__ */ new Set();
+  const setStatus = (s) => {
+    if (s !== status) {
+      status = s;
+      statusFns.forEach((f) => f(s));
+    }
+  };
+  const schedule = () => {
+    if (closed) return;
+    timer = setTimeout(open, backoff);
+    backoff = Math.min(max, backoff * 2);
+  };
+  function open() {
+    if (closed) return;
+    setStatus(status === "open" ? "connecting" : status);
+    if (!token) {
+      dial(new Ws(opts.url));
+      return;
+    }
+    const mine = ++attempt;
+    void token.get(failed).then((r) => {
+      if (closed || mine !== attempt) return;
+      if (r.kind === "token") {
+        try {
+          dial(new Ws(opts.url, [DAEMON_PROTOCOL_PREFIX + r.token]));
+          return;
+        } catch {
+        }
+      }
+      failed = true;
+      setStatus("unreachable");
+      schedule();
+    });
+  }
+  function dial(sock) {
+    ws = sock;
+    let opened = false;
+    sock.onopen = () => {
+      if (ws !== sock) return;
+      opened = true;
+      setStatus("open");
+    };
+    sock.onmessage = (ev) => {
+      if (ws !== sock) return;
+      try {
+        const m = parseServerMessage(JSON.parse(String(ev.data)));
+        if (m.type === "snapshot") {
+          backoff = min;
+          failed = false;
+        }
+        msgFns.forEach((f) => f(m));
+      } catch {
+      }
+    };
+    sock.onerror = () => {
+    };
+    sock.onclose = () => {
+      if (ws !== sock) return;
+      ws = null;
+      if (!opened) failed = true;
+      setStatus("unreachable");
+      schedule();
+    };
+  }
+  return {
+    // An explicit connect (a « Reconnect ») says « connecting » at once, even after a drop: the automatic retries stay « unreachable ».
+    connect: () => {
+      closed = false;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      const old = ws;
+      ws = null;
+      old?.close();
+      setStatus("connecting");
+      open();
+    },
+    close: () => {
+      closed = true;
+      attempt++;
+      if (timer) clearTimeout(timer);
+      const old = ws;
+      ws = null;
+      old?.close();
+      setStatus("connecting");
+    },
+    send: (m) => {
+      if (ws && ws.readyState === 1) ws.send(JSON.stringify(m));
+    },
+    status: () => status,
+    onMessage: (f) => {
+      msgFns.add(f);
+      return () => msgFns.delete(f);
+    },
+    onStatus: (f) => {
+      statusFns.add(f);
+      return () => statusFns.delete(f);
+    }
+  };
+}
+
+// ../ui/src/launch/rigModel.ts
+var STOP = /* @__PURE__ */ new Set(["le", "la", "les", "de", "des", "du", "un", "une", "et", "\xE0", "au", "pour", "sur", "apr\xE8s", "avant"]);
+var LONG_WORDS = ["jours", "dur\xE9e", "produit", "livrer", "plusieurs"];
+var LONG_GOAL = 160;
+var fold = (s) => s.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "");
+function slugOfGoal(goal) {
+  const words = goal.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((w) => w && !STOP.has(w)).map(fold).map((w) => w.replace(/[^a-z0-9]/g, "")).filter(Boolean);
+  const slug = words.slice(-2).join("-").slice(0, 40).replace(/-+$/, "");
+  return RIG_NAME.test(slug) ? slug : "rig";
+}
+function rigFormDefaults(p) {
+  const goal = p.wanted.goal ?? "";
+  const spec = p.wanted.spec ?? null;
+  const machine = p.machines.find((m) => m.id === p.wanted.machine)?.id ?? p.machines.find((m) => m.id === "local")?.id ?? p.machines[0]?.id ?? "local";
+  const project = p.projects.find((x) => x.id === p.wanted.project);
+  if (!project) return { goal, spec, machine, place: p.wanted.off ? { kind: "off", name: p.wanted.off, nameTouched: true } : { kind: "off", name: slugOfGoal(goal), nameTouched: false } };
+  const repo = project.repos.find((r) => r.machine === machine)?.path ?? null;
+  return { goal, spec, machine, place: { kind: "project", projectId: project.id, repo, branch: spec ? `feat/${spec}` : "", copy: true } };
+}
+function withGoal(f, goal) {
+  const place = f.place.kind === "off" && !f.place.nameTouched ? { ...f.place, name: slugOfGoal(goal) } : f.place;
+  return { ...f, goal, place };
+}
+function recommendSpec(goal, specs) {
+  const g = goal.toLowerCase();
+  const long = goal.length > LONG_GOAL || LONG_WORDS.some((w) => g.includes(w));
+  const spec = long ? "factory" : "starter";
+  return specs.some((s) => s.name === spec || s.id === spec) ? { spec, why: long ? "long" : "bounded" } : null;
+}
+function missingOf(f) {
+  const out = [];
+  if (!f.goal.trim()) out.push("goal");
+  if (!f.spec) out.push("spec");
+  if (f.place.kind === "project") {
+    if (!f.place.repo) out.push("repo");
+    const b = f.place.branch.trim();
+    if (!b || b.startsWith("-")) out.push("branch");
+  } else if (!RIG_NAME.test(f.place.name)) out.push("name");
+  return out;
+}
+function whereOf(f) {
+  const missing = missingOf(f);
+  if (f.place.kind === "project") {
+    if (missing.includes("repo") || missing.includes("branch") || !f.place.repo) return null;
+    return { kind: "project", projectId: f.place.projectId, repo: f.place.repo, branch: f.place.branch.trim(), copy: f.place.copy };
+  }
+  return missing.includes("name") ? null : { kind: "off-project", name: f.place.name };
+}
+var planRequired = (f) => f.place.kind === "project" && !f.place.copy;
+var primaryAction = (f) => planRequired(f) ? "plan" : "launch";
+function providers(seats) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const s of seats) counts.set(s.runtime, (counts.get(s.runtime) ?? 0) + 1);
+  return [...counts].map(([runtime, count]) => ({ runtime, count }));
+}
+function launchability(m, status) {
+  if (m.status !== "open") return { ok: false, why: "offline" };
+  if (!status) return { ok: false, why: "unreachable" };
+  switch (status.state) {
+    case "running":
+    case "stopped":
+    case "starting":
+      return { ok: true };
+    case "absent":
+      return status.install ? { ok: false, why: "absent", install: status.install } : { ok: false, why: "absent" };
+    case "unsupported":
+      return { ok: false, why: "unsupported" };
+    default:
+      return { ok: false, why: "unreachable" };
+  }
+}
+
+export {
+  imageInfo,
+  rigKey,
+  rigColor,
+  kernelSplit,
+  workingCount,
+  rigPlace,
+  isStandalone,
+  seatMentions,
+  ledgeLine,
+  shortCwd,
+  runtimeLabel,
+  DAEMON_PROTOCOL_PREFIX,
+  createTokenSource,
+  createDaemonClient,
+  slugOfGoal,
+  rigFormDefaults,
+  withGoal,
+  recommendSpec,
+  missingOf,
+  whereOf,
+  primaryAction,
+  providers,
+  launchability
+};