@runeya/runeya 2.0.146 → 2.0.147

package/chunk-7QXP4FXD.js

@@ -0,0 +1,969 @@
+import {
+  serviceStore
+} from "./chunk-4D3GCBPO.js";
+import {
+  AmbiguousProjectError,
+  StoreDiskCoordinator,
+  environmentStore,
+  forgetProject,
+  projectKey,
+  recordDetached,
+  registerProjectLoader,
+  setProjectServices,
+  setProjectVault
+} from "./chunk-DFPZ4MTI.js";
+import {
+  atomicWriteSecure,
+  fingerprintFiles
+} from "./chunk-4LJQIQMN.js";
+import {
+  collidesWithMachineRoot,
+  forgetLocalProjectRoot,
+  listCloudVaults,
+  localProjectVaultRoot,
+  localVaultCollidesWithMachineRoot,
+  localVaultRoot,
+  machineFilePath,
+  machineRoot,
+  readLocalProjectDirs,
+  registerLocalProjectDir,
+  setLocalProjectRoot,
+  unregisterLocalProjectDir,
+  vaultFor
+} from "./chunk-VPSQJOSN.js";
+import {
+  ProjectSchema
+} from "./chunk-MZSDTA4A.js";
+
+// ../server/src/services/project-store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { EventEmitter } from "events";
+import { mkdir as mkdir2, readFile as readFile3, rename as rename2, rm } from "fs/promises";
+import { dirname, join as join3, resolve as resolve2 } from "path";
+
+// ../server/src/utils/ensure-data-gitignore.ts
+import { writeFile } from "fs/promises";
+import { join } from "path";
+var GITIGNORE_CONTENT = `
+#################
+# Do not edit this file #
+#################
+
+
+# Encryption key (contains secrets \u2014 never commit)
+.encryption.key
+.encryption.key.enc
+
+
+# Key verification canary \u2014 MUST be committed so new team members can validate their encryption key
+!.runeya-verify
+
+# This machine's cloud session token (encrypted, and specific to this install)
+cloud-session.json
+
+# Backup in local only
+backup-*
+
+# Per-user environment overrides (never commit \u2014 each dev has their own)
+environment-overrides.json
+
+# Private user data (conversations, personal state \u2014 never commit)
+*.private
+*.private.json*
+conversations/
+conversations.private.json
+
+
+
+# Runtime logs
+*.log
+*.log.*
+`;
+async function ensureDataGitignore(dataDir) {
+  const gitignorePath = join(dataDir, ".gitignore");
+  await writeFile(gitignorePath, GITIGNORE_CONTENT, "utf-8");
+}
+
+// ../server/src/services/conversation-section-store.ts
+import { randomUUID } from "crypto";
+import { readFile } from "fs/promises";
+var FILENAME = "conversation-sections.json";
+function isSectionMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.values(value).every((list) => Array.isArray(list) && list.every((s) => !!s && typeof s === "object" && typeof s.id === "string" && typeof s.name === "string" && typeof s.order === "number"));
+}
+var ConversationSectionStore = class {
+  async read() {
+    try {
+      const parsed = JSON.parse(await readFile(machineFilePath(FILENAME), "utf-8"));
+      return isSectionMap(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  async write(map) {
+    await atomicWriteSecure(machineFilePath(FILENAME), JSON.stringify(map, null, 2));
+  }
+  /** Les sections d'un projet, dans l'ordre choisi. */
+  async list(projectId) {
+    const map = await this.read();
+    return (map[projectId] ?? []).slice().sort((a, b) => a.order - b.order);
+  }
+  async get(projectId, id) {
+    return (await this.list(projectId)).find((s) => s.id === id) ?? null;
+  }
+  /** Crée une section, posée après les autres. */
+  async create(projectId, name) {
+    const map = await this.read();
+    const list = map[projectId] ?? [];
+    const order = list.length > 0 ? Math.max(...list.map((s) => s.order)) + 1 : 0;
+    const section = { id: randomUUID(), name, order };
+    map[projectId] = [...list, section];
+    await this.write(map);
+    return section;
+  }
+  async rename(projectId, id, name) {
+    const map = await this.read();
+    const section = map[projectId]?.find((s) => s.id === id);
+    if (!section) return null;
+    section.name = name;
+    await this.write(map);
+    return section;
+  }
+  /** Retire une section. Rend `false` si elle n'existait pas. */
+  async remove(projectId, id) {
+    const map = await this.read();
+    const list = map[projectId] ?? [];
+    const next = list.filter((s) => s.id !== id);
+    if (next.length === list.length) return false;
+    if (next.length > 0) map[projectId] = next;
+    else delete map[projectId];
+    await this.write(map);
+    return true;
+  }
+  /**
+   * Range les sections du projet dans l'ordre de `ids`.
+   *
+   * Une section absente de `ids` passe après les autres, dans son ordre
+   * d'avant : un appel parti avant la création d'une section ne la fait pas
+   * disparaître. Un id inconnu est ignoré.
+   */
+  async reorder(projectId, ids) {
+    const map = await this.read();
+    const list = (map[projectId] ?? []).slice().sort((a, b) => a.order - b.order);
+    if (list.length === 0) return;
+    const rank = new Map(Array.from(new Set(ids)).map((id, i) => [id, i]));
+    const listed = list.filter((s) => rank.has(s.id)).sort((a, b) => rank.get(a.id) - rank.get(b.id));
+    const others = list.filter((s) => !rank.has(s.id));
+    map[projectId] = [...listed, ...others].map((s, i) => ({ ...s, order: i }));
+    await this.write(map);
+  }
+  /** Oublie les sections d'un projet supprimé. */
+  async forgetProject(projectId) {
+    const map = await this.read();
+    if (!(projectId in map)) return;
+    delete map[projectId];
+    await this.write(map);
+  }
+};
+var conversationSectionStore = new ConversationSectionStore();
+
+// ../server/src/services/project-path-store.ts
+import { readFile as readFile2, writeFile as writeFile2, rename, mkdir, chmod, stat } from "fs/promises";
+import { isAbsolute, join as join2, resolve } from "path";
+var FILENAME2 = "project-paths.json";
+var ProjectPathStore = class {
+  paths = null;
+  async load() {
+    if (this.paths) return this.paths;
+    try {
+      const raw = await readFile2(machineFilePath(FILENAME2), "utf-8");
+      const parsed = JSON.parse(raw);
+      this.paths = isPathMap(parsed) ? parsed : {};
+    } catch {
+      this.paths = {};
+    }
+    return this.paths;
+  }
+  async persist() {
+    await mkdir(machineRoot(), { recursive: true });
+    const filePath = machineFilePath(FILENAME2);
+    const tmpPath = `${filePath}.tmp`;
+    await writeFile2(tmpPath, JSON.stringify(this.paths ?? {}, null, 2), "utf-8");
+    await rename(tmpPath, filePath);
+    await chmod(filePath, 384);
+  }
+  /** The directory chosen for this project, or null while it has none. */
+  async get(ref) {
+    const paths = await this.load();
+    return paths[projectKey(ref)] ?? paths[ref.id] ?? null;
+  }
+  async all() {
+    return { ...await this.load() };
+  }
+  /**
+   * The project already placed in this directory, if any other one is.
+   *
+   * Answers with the key as stored — the couple, or the bare id for an entry an
+   * older version wrote — which is enough to say "taken" and to name it.
+   *
+   * `isKnown` écarte les entrées d'un projet que ce poste ne connaît plus : un
+   * projet disparu ne doit pas continuer de retenir son dossier.
+   */
+  async projectAt(path, exclude, isKnown = () => true) {
+    const target = resolve(path);
+    const excluded = exclude ? [projectKey(exclude), exclude.id] : [];
+    for (const [key, dir] of Object.entries(await this.load())) {
+      if (!excluded.includes(key) && resolve(dir) === target && isKnown(key)) return key;
+    }
+    return null;
+  }
+  async set(ref, path) {
+    if (!isAbsolute(path)) throw new Error("Le chemin du projet doit \xEAtre absolu");
+    const paths = await this.load();
+    delete paths[ref.id];
+    paths[projectKey(ref)] = resolve(path);
+    await this.persist();
+  }
+  /**
+   * Faire suivre le répertoire quand un projet change d'organisation.
+   *
+   * La clé est le couple `(organisation, projet)` : publier un projet local le
+   * fait passer de `local:<id>` à `<org>:<id>`, et l'entrée d'avant cesse alors
+   * de répondre — `get` ne retombe que sur l'identifiant nu, forme héritée, pas
+   * sur `local:<id>`. Le projet se retrouvait donc sans emplacement connu juste
+   * après avoir été publié, alors que ses sources n'avaient pas bougé d'un
+   * octet.
+   */
+  async relocate(from, to) {
+    const paths = await this.load();
+    const previous = paths[projectKey(from)] ?? paths[from.id];
+    if (!previous) return;
+    delete paths[projectKey(from)];
+    delete paths[from.id];
+    paths[projectKey(to)] = previous;
+    await this.persist();
+  }
+  async clear(ref) {
+    const paths = await this.load();
+    const keys = [projectKey(ref), ref.id].filter((k) => k in paths);
+    if (keys.length === 0) return;
+    for (const key of keys) delete paths[key];
+    await this.persist();
+  }
+  /** Test seam: forget what was read from disk. */
+  reset() {
+    this.paths = null;
+  }
+};
+function isPathMap(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((v) => typeof v === "string");
+}
+async function holdsRuneyaProject(path) {
+  return stat(join2(path, ".runeya", "project.json")).then(() => true, () => false);
+}
+var projectPathStore = new ProjectPathStore();
+
+// ../server/src/services/project-store.ts
+var FILENAME3 = "project.json";
+var LEGACY_FILENAME = "projects.json";
+function toDiskForm(project) {
+  const { activeEnvironmentId: _runtimeOnly, ...rest } = project;
+  return rest;
+}
+async function readLocalProject() {
+  const root = localVaultRoot();
+  let current = null;
+  try {
+    const raw = await readFile3(join3(root, FILENAME3), "utf-8");
+    const parsed = ProjectSchema.safeParse(JSON.parse(raw));
+    if (parsed.success) current = parsed.data;
+  } catch {
+  }
+  let legacy;
+  try {
+    legacy = JSON.parse(await readFile3(join3(root, LEGACY_FILENAME), "utf-8"));
+  } catch {
+    return { local: current, strayCloud: [] };
+  }
+  const strayCloud = legacy.filter((p) => p.orgId);
+  if (current) return { local: current, strayCloud };
+  const locals = legacy.filter((p) => !p.orgId);
+  if (locals.length > 1) {
+    const names = locals.map((p) => `"${p.name}" (${p.id})`).join(", ");
+    throw new Error(
+      `${join3(root, LEGACY_FILENAME)} holds ${locals.length} local projects: ${names}. A directory now holds a single local project \u2014 move the others to their own directory, or into an organization, then start again.`
+    );
+  }
+  return { local: locals[0] ?? null, strayCloud };
+}
+function isRegistrable(root) {
+  return localProjectVaultRoot(dirname(root)) === resolve2(root);
+}
+async function readLocalProjectAt(root) {
+  try {
+    const parsed = ProjectSchema.safeParse(JSON.parse(await readFile3(join3(root, FILENAME3), "utf-8")));
+    return parsed.success && !parsed.data.orgId ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function readCloudProjects() {
+  const found = [];
+  for (const { orgId, projectId, root } of await listCloudVaults()) {
+    try {
+      const raw = await readFile3(join3(root, FILENAME3), "utf-8");
+      const parsed = ProjectSchema.safeParse({ ...JSON.parse(raw), id: projectId, orgId });
+      if (parsed.success) found.push({ project: parsed.data, root });
+    } catch {
+    }
+  }
+  return found;
+}
+var LocalProjectRefusedError = class extends Error {
+};
+var LocalProjectExistsError = class extends LocalProjectRefusedError {
+  constructor(projectName) {
+    super(
+      `This directory already holds the local project "${projectName}". A directory holds one local project: use another directory, or create the project in an organization.`
+    );
+    this.projectName = projectName;
+    this.name = "LocalProjectExistsError";
+  }
+  code = "LOCAL_PROJECT_EXISTS";
+};
+var LocalProjectInMachineRootError = class extends LocalProjectRefusedError {
+  code = "LOCAL_PROJECT_IN_MACHINE_ROOT";
+  constructor() {
+    super(
+      "This directory holds Runeya's own data. A local project here would mix its files with the machine's vaults: launch Runeya from another directory, or create the project in an organization."
+    );
+    this.name = "LocalProjectInMachineRootError";
+  }
+};
+var LocalProjectCloudLinkedError = class extends LocalProjectRefusedError {
+  code = "LOCAL_PROJECT_CLOUD_LINKED";
+  constructor() {
+    super("This directory is already linked to an organization project. Choose another directory.");
+    this.name = "LocalProjectCloudLinkedError";
+  }
+};
+var LocalProjectNotFoundError = class extends LocalProjectRefusedError {
+  code = "LOCAL_PROJECT_NOT_FOUND";
+  constructor() {
+    super("This directory holds no local Runeya project to import.");
+    this.name = "LocalProjectNotFoundError";
+  }
+};
+var ProjectStore = class {
+  /**
+   * Keyed by the (organization, project) couple, never by the project id alone:
+   * the same id can name a different project in each organization, and keying
+   * by id let the second one read from disk overwrite the first — then `save()`
+   * wrote that survivor back into both vaults.
+   */
+  projects = /* @__PURE__ */ new Map();
+  /**
+   * Les coffres où un projet local a été lu ou écrit. À l'écriture, un coffre
+   * de cette liste qui n'a plus de projet perd sa fiche : c'est ainsi qu'une
+   * suppression ou une publication vide le dossier qu'elle quitte.
+   */
+  localRoots = /* @__PURE__ */ new Set();
+  loaded = false;
+  /**
+   * L'état du disque tel qu'il était au dernier chargement.
+   *
+   * Plusieurs Runeya partagent la racine machine — l'application installée et
+   * celle qu'on développe, couramment — et créent donc des projets dans les
+   * mêmes coffres. Un store chargé une fois pour toutes ne voit jamais le
+   * travail de l'autre : il faudrait le redémarrer pour qu'un projet créé à
+   * côté existe pour lui.
+   */
+  fingerprint = "";
+  disk = new StoreDiskCoordinator();
+  /** Emits `'saved'` after every persisted mutation, for the cloud sync bridge. */
+  events = new EventEmitter();
+  getFilePath(root = localVaultRoot()) {
+    return join3(root, FILENAME3);
+  }
+  /** Adopt a project read from disk, remembering which vault it came from. */
+  async absorb(into, p, root) {
+    const projectEnvs = await environmentStore.getByProjectId(p.id).catch(() => []);
+    const defaultEnv = projectEnvs.find((e) => e.default);
+    into.set(projectKey(p), {
+      ...p,
+      environmentIds: p.environmentIds ?? [],
+      groupOrder: p.groupOrder ?? [],
+      // Prefer the env marked default, fall back to first env
+      activeEnvironmentId: defaultEnv?.id ?? p.environmentIds?.[0]
+    });
+    if (!p.orgId) {
+      setLocalProjectRoot(p.id, root);
+      this.localRoots.add(root);
+    }
+    setProjectVault(p, root);
+    setProjectServices(p, p.serviceIds ?? []);
+  }
+  /**
+   * Ce que le disque porte : quels coffres, et quand leur fiche a changé.
+   *
+   * Les coffres sont demandés à `listCloudVaults`, qui les découvre déjà par
+   * balayage — en refaire un ici donnerait deux inventaires à tenir d'accord.
+   * Seules les dates sont relevées : lire et analyser les fiches, puis les
+   * absorber (ce qui va interroger les environnements), est justement ce que ce
+   * repère évite de refaire à chaque appel.
+   */
+  async diskFingerprint() {
+    return fingerprintFiles([
+      this.getFilePath(),
+      ...(await readLocalProjectDirs()).map((dir) => this.getFilePath(localProjectVaultRoot(dir))),
+      ...(await listCloudVaults()).map((v) => this.getFilePath(v.root))
+    ]);
+  }
+  /**
+   * Read every vault: the launch directory, then each organization's projects.
+   *
+   * Cloud vaults are discovered by walking `~/.runeya/orgs/*&#47;projects/*` rather
+   * than from an index. An index is one more thing that can disagree with the
+   * disk — and a project present on disk but missing from it is exactly the
+   * "already here, still shown as downloadable" bug.
+   *
+   * Relu quand le disque a bougé, pas une fois pour toutes : une autre instance
+   * partageant cette racine machine y crée des projets, et ne jamais relire
+   * reviendrait à exiger un redémarrage pour les voir.
+   */
+  async load() {
+    let migrated = false;
+    await this.disk.load(async () => {
+      const fingerprint = await this.diskFingerprint();
+      if (this.loaded && fingerprint === this.fingerprint) return null;
+      const next = await this.readVaults();
+      return () => {
+        for (const [key, project] of next.projects) {
+          const before = this.projects.get(key)?.activeEnvironmentId;
+          if (before && project.environmentIds.includes(before)) {
+            project.activeEnvironmentId = before;
+          } else {
+            this.unsettled.add(key);
+          }
+        }
+        this.projects = next.projects;
+        this.fingerprint = fingerprint;
+        this.loaded = true;
+        migrated = next.migrated;
+      };
+    });
+    if (migrated) {
+      await this.save();
+      await serviceStore.relocateAll();
+      await environmentStore.relocateAll();
+    }
+  }
+  /** Le parcours proprement dit, dans une table neuve que `load` substitue. */
+  async readVaults() {
+    const projects = /* @__PURE__ */ new Map();
+    this.localRoots = /* @__PURE__ */ new Set();
+    const { local, strayCloud } = await readLocalProject();
+    if (local) {
+      await this.absorb(projects, local, localVaultRoot());
+      if (!localVaultCollidesWithMachineRoot() && isRegistrable(localVaultRoot())) {
+        await registerLocalProjectDir(dirname(localVaultRoot())).catch(() => {
+        });
+      }
+    }
+    for (const dir of await readLocalProjectDirs()) {
+      const root = localProjectVaultRoot(dir);
+      if (root === localVaultRoot()) continue;
+      const found = await readLocalProjectAt(root);
+      if (!found || projects.has(projectKey(found))) continue;
+      await this.absorb(projects, found, root);
+    }
+    let migrated = false;
+    for (const project of strayCloud) {
+      try {
+        await this.absorb(projects, project, vaultFor(project).root);
+        migrated = true;
+      } catch {
+      }
+    }
+    for (const { project, root } of await readCloudProjects()) {
+      await this.absorb(projects, project, root);
+    }
+    return { projects, migrated };
+  }
+  /**
+   * Persist every vault this store knows about.
+   *
+   * Writing all of them rather than only the one that changed keeps a project
+   * that moved between vaults — a local project adopted by an org, a cloud
+   * project pulled for the first time — from lingering in the vault it left.
+   */
+  save() {
+    return this.disk.save(() => this.writeVaults());
+  }
+  async writeVaults() {
+    const locals = [];
+    const cloud = [];
+    for (const project of this.projects.values()) {
+      if (!project.orgId) locals.push(project);
+      else cloud.push({ project, root: vaultFor(project).root });
+    }
+    const written = /* @__PURE__ */ new Map();
+    for (const local of locals) {
+      const root = vaultFor(local).root;
+      const other = written.get(root);
+      if (other) {
+        throw new Error(
+          `Refusing to save two local projects in ${root}: "${other.name}" and "${local.name}". A directory holds a single local project.`
+        );
+      }
+      written.set(root, local);
+    }
+    for (const [root, local] of written) {
+      await mkdir2(root, { recursive: true });
+      await ensureDataGitignore(root);
+      await atomicWriteSecure(this.getFilePath(root), JSON.stringify(toDiskForm(local), null, 2));
+      this.localRoots.add(root);
+    }
+    for (const root of this.localRoots) {
+      if (written.has(root)) continue;
+      await rm(this.getFilePath(root), { force: true }).catch(() => {
+      });
+      if (isRegistrable(root)) await unregisterLocalProjectDir(dirname(root)).catch(() => {
+      });
+      this.localRoots.delete(root);
+    }
+    await rename2(join3(localVaultRoot(), LEGACY_FILENAME), join3(localVaultRoot(), LEGACY_FILENAME + ".bak")).catch(() => {
+    });
+    for (const { project, root } of cloud) {
+      await atomicWriteSecure(this.getFilePath(root), JSON.stringify(toDiskForm(project), null, 2));
+      setProjectVault(project, root);
+    }
+    this.fingerprint = await this.diskFingerprint();
+    this.events.emit("saved");
+  }
+  /**
+   * The project a caller means, from a couple or from a bare id.
+   *
+   * A ref carrying its `orgId` — even an explicit `null` for a local project —
+   * names exactly one project and is looked up directly. A bare id is what a
+   * contained entity (an environment, a conversation) still carries, and it is
+   * resolved only while it answers for a single project: electing one of two
+   * would write into the wrong organization's vault.
+   */
+  resolveKey(target) {
+    if (typeof target !== "string" && target.orgId !== void 0) return projectKey(target);
+    const id = typeof target === "string" ? target : target.id;
+    const matches = Array.from(this.projects.values()).filter((p) => p.id === id);
+    if (matches.length > 1) {
+      throw new AmbiguousProjectError(id, matches.map((p) => p.orgId ?? null));
+    }
+    return matches[0] ? projectKey(matches[0]) : null;
+  }
+  find(target) {
+    const key = this.resolveKey(target);
+    const project = key ? this.projects.get(key) : void 0;
+    return key && project ? { key, project } : null;
+  }
+  /**
+   * Le projet déjà placé dans ce dossier, parmi ceux que ce poste connaît.
+   *
+   * Une entrée de `project-paths.json` peut survivre à son projet (supprimé
+   * ailleurs, ou avant que la suppression ne la nettoie). Elle ne réserve plus
+   * rien : le refus qui en découlait nommait un projet introuvable.
+   */
+  async projectAtPath(path, exclude) {
+    await this.load();
+    const ids = new Set(Array.from(this.projects.values(), (p) => p.id));
+    return projectPathStore.projectAt(path, exclude, (key) => this.projects.has(key) || ids.has(key));
+  }
+  async list() {
+    await this.load();
+    await this.settleActiveEnvironments();
+    return Array.from(this.projects.values());
+  }
+  async get(target) {
+    await this.load();
+    await this.settleActiveEnvironments();
+    return this.find(target)?.project ?? null;
+  }
+  /**
+   * Projets dont l'environnement actif vient d'un repli et n'a pas été vérifié.
+   *
+   * Au chargement, les environnements ne sont pas encore lisibles : leur magasin
+   * attend justement la fin de ce chargement. `absorb` retient donc le premier
+   * id de `environmentIds`, qui peut désigner un environnement disparu. Le
+   * sélecteur affichait alors cet id brut, absent de sa liste.
+   */
+  unsettled = /* @__PURE__ */ new Set();
+  settling = false;
+  /** Retenir, pour chaque projet non vérifié, un environnement qui existe. */
+  async settleActiveEnvironments() {
+    if (this.settling || this.unsettled.size === 0) return;
+    this.settling = true;
+    try {
+      for (const key of this.unsettled) {
+        const project = this.projects.get(key);
+        if (!project) {
+          this.unsettled.delete(key);
+          continue;
+        }
+        const envs = (await environmentStore.getByProjectId(project.id, project.orgId ?? null).catch(() => [])).filter((e) => e.scope !== "service");
+        if (envs.length === 0) continue;
+        const current = envs.find((e) => e.id === project.activeEnvironmentId);
+        const chosen = envs.find((e) => e.default) ?? current ?? envs[0];
+        project.activeEnvironmentId = chosen.id;
+        this.unsettled.delete(key);
+      }
+    } finally {
+      this.settling = false;
+    }
+  }
+  /**
+   * Vérifier qu'un dossier peut accueillir un projet local, et rendre son coffre.
+   *
+   * Refusé si son `.runeya` serait la racine machine, si le dossier est déjà
+   * l'emplacement d'un projet d'organisation, ou s'il porte déjà un projet.
+   */
+  async localRootFor(root) {
+    if (collidesWithMachineRoot(root)) throw new LocalProjectInMachineRootError();
+    if (await this.projectAtPath(dirname(root))) throw new LocalProjectCloudLinkedError();
+    const known = Array.from(this.projects.values()).find((p) => !p.orgId && vaultFor(p).root === root);
+    if (known) throw new LocalProjectExistsError(known.name);
+    const onDisk = await readLocalProjectAt(root);
+    if (onDisk) throw new LocalProjectExistsError(onDisk.name);
+    if (root !== localVaultRoot() && await holdsRuneyaProject(dirname(root))) throw new LocalProjectExistsError("");
+    return root;
+  }
+  /**
+   * `localDir` : le dossier d'un projet local. Omis, c'est le dossier de
+   * lancement, comme avant que les projets locaux aient chacun le leur.
+   */
+  async create(input, localDir) {
+    await this.load();
+    const localRoot = input.orgId ? null : await this.localRootFor(localDir ? localProjectVaultRoot(localDir) : localVaultRoot());
+    const project = {
+      id: randomUUID2(),
+      orgId: input.orgId ?? null,
+      name: input.name,
+      description: input.description ?? "",
+      serviceIds: input.serviceIds ?? [],
+      environmentIds: input.environmentIds ?? [],
+      activeEnvironmentId: input.activeEnvironmentId,
+      groupOrder: input.groupOrder ?? []
+    };
+    this.projects.set(projectKey(project), project);
+    if (localRoot) {
+      setLocalProjectRoot(project.id, localRoot);
+      if (isRegistrable(localRoot)) await registerLocalProjectDir(dirname(localRoot));
+    }
+    setProjectVault(project, vaultFor(project).root);
+    setProjectServices(project, project.serviceIds);
+    await this.save();
+    return project;
+  }
+  /**
+   * Ce qu'un dossier permet pour un projet local : en créer un (`available`),
+   * importer celui qu'il porte (`importable`), rien parce qu'il est déjà dans
+   * la liste (`listed`), ou rien parce qu'il est refusé.
+   */
+  async inspectLocalDir(dir) {
+    await this.load();
+    const root = localProjectVaultRoot(dir);
+    if (collidesWithMachineRoot(root)) return { status: "machine-root", projectName: null };
+    if (await this.projectAtPath(resolve2(dir))) return { status: "cloud-linked", projectName: null };
+    const known = Array.from(this.projects.values()).find((p) => !p.orgId && vaultFor(p).root === root);
+    if (known) return { status: "listed", projectName: known.name };
+    const onDisk = await readLocalProjectAt(root);
+    if (onDisk) return { status: "importable", projectName: onDisk.name };
+    if (await holdsRuneyaProject(dirname(root))) return { status: "unreadable", projectName: null };
+    return { status: "available", projectName: null };
+  }
+  /**
+   * Ajouter à la liste le projet local déjà présent dans ce dossier.
+   *
+   * Son `.runeya` n'est pas touché : le dossier est seulement enregistré, et le
+   * projet relu comme les autres.
+   */
+  async importLocal(dir) {
+    await this.load();
+    const root = localProjectVaultRoot(dir);
+    if (collidesWithMachineRoot(root)) throw new LocalProjectInMachineRootError();
+    if (await this.projectAtPath(resolve2(dir))) throw new LocalProjectCloudLinkedError();
+    const found = await readLocalProjectAt(root);
+    if (!found) throw new LocalProjectNotFoundError();
+    const known = this.projects.get(projectKey(found));
+    if (known) return known;
+    await registerLocalProjectDir(dirname(root));
+    this.loaded = false;
+    await this.load();
+    return this.projects.get(projectKey(found)) ?? found;
+  }
+  /**
+   * `input.orgId` names which project is being updated, it does not move it:
+   * a project is born local or in an organization and stays there, so treating
+   * it as a new value would silently relocate a vault instead of editing it.
+   */
+  async update(input) {
+    await this.load();
+    const found = this.find(input);
+    if (!found) return null;
+    const { key, project: existing } = found;
+    const updated = {
+      ...existing,
+      ...input.name !== void 0 && { name: input.name },
+      ...input.description !== void 0 && { description: input.description },
+      ...input.serviceIds !== void 0 && { serviceIds: input.serviceIds },
+      ...input.environmentIds !== void 0 && { environmentIds: input.environmentIds },
+      ...input.activeEnvironmentId !== void 0 && { activeEnvironmentId: input.activeEnvironmentId },
+      ...input.groupOrder !== void 0 && { groupOrder: input.groupOrder }
+    };
+    recordDetached(existing.id, "serviceIds", existing.serviceIds ?? [], updated.serviceIds ?? []);
+    recordDetached(existing.id, "environmentIds", existing.environmentIds ?? [], updated.environmentIds ?? []);
+    this.projects.set(key, updated);
+    setProjectVault(updated, vaultFor(updated).root);
+    setProjectServices(updated, updated.serviceIds);
+    await this.save();
+    return updated;
+  }
+  /**
+   * Faire passer le projet local de ce dossier dans une organisation.
+   *
+   * Le seul déplacement de coffre qu'on s'autorise, et il ne va que dans ce
+   * sens : le projet quitte `<cwd>/.runeya` pour
+   * `~/.runeya/orgs/<org>/projects/<id>/`, en gardant son identifiant. Il n'y a
+   * donc jamais deux copies à réconcilier — c'est ce qui rendait « publier »
+   * dangereux tant que le projet restait aussi local.
+   *
+   * Refusé si l'organisation porte déjà ce projet : la copie d'ici écraserait
+   * celle du cloud, et ces deux histoires ne sont pas à nous de les fusionner.
+   *
+   * Ce qui suit le projet est écrit par les stores eux-mêmes : `save()` réécrit
+   * chaque coffre — le fichier local disparaît, celui de l'org apparaît — puis
+   * les contenus sont relogés depuis le registre, qui pointe désormais ailleurs.
+   */
+  async moveToOrg(projectId, orgId) {
+    await this.load();
+    const local = this.projects.get(projectKey({ id: projectId, orgId: null }));
+    if (!local) throw new Error("PROJECT_NOT_LOCAL");
+    if (this.projects.get(projectKey({ id: projectId, orgId }))) {
+      throw new Error("PROJECT_ALREADY_IN_ORG");
+    }
+    const localRoot = vaultFor(local).root;
+    const localDir = localRoot === localVaultRoot() ? null : dirname(localRoot);
+    const moved = { ...local, orgId };
+    this.projects.delete(projectKey(local));
+    forgetProject(local);
+    forgetLocalProjectRoot(local.id);
+    this.projects.set(projectKey(moved), moved);
+    setProjectVault(moved, vaultFor(moved).root);
+    setProjectServices(moved, moved.serviceIds ?? []);
+    await this.save();
+    if (localDir && !await projectPathStore.get(moved)) {
+      await projectPathStore.set(moved, localDir);
+    }
+    await serviceStore.reassignOrg(moved.serviceIds ?? [], orgId);
+    await environmentStore.relocateAll();
+    return moved;
+  }
+  async delete(target) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return false;
+    const { key, project } = found;
+    this.projects.delete(key);
+    await this.save();
+    await this.discardVault(project);
+    await projectPathStore.clear(project);
+    await conversationSectionStore.forgetProject(project.id);
+    return true;
+  }
+  /**
+   * Remove what a deleted cloud project left behind.
+   *
+   * Its vault is a directory of its own, so dropping the project means dropping
+   * the directory — otherwise `readCloudVaults` would resurrect it on the next
+   * load. Local projects share their vault with the directory's own files and
+   * are only removed from the list.
+   */
+  async discardVault(project) {
+    forgetProject(project);
+    if (!project.orgId) forgetLocalProjectRoot(project.id);
+    if (!project.orgId) return;
+    await rm(vaultFor(project).root, { recursive: true, force: true }).catch(() => {
+    });
+  }
+  /**
+   * Stop holding a project on this machine, leaving the doc alone.
+   *
+   * Memory only: the caller removes the vault itself. Its contents are dropped
+   * too, because a service or environment surviving in memory would be written
+   * back on the next save — and, its project being unknown by then, into the
+   * local vault.
+   */
+  async forgetLocally(target) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return;
+    const { key, project } = found;
+    this.projects.delete(key);
+    forgetProject(project);
+    await serviceStore.forgetLocally(project.serviceIds ?? []);
+    await environmentStore.forgetByProject(project.id);
+    await projectPathStore.clear(project);
+  }
+  /**
+   * Le projet qui porte un service, ou `null` s'il n'est rattaché à aucun.
+   *
+   * Un service n'appartient qu'à un projet : la recherche s'arrête au premier.
+   */
+  async ofService(serviceId) {
+    await this.load();
+    for (const project of this.projects.values()) {
+      if (project.serviceIds.includes(serviceId)) return project;
+    }
+    return null;
+  }
+  /** All projects linked to a given organization (for the sync bridge). */
+  async listByOrg(orgId) {
+    await this.load();
+    return Array.from(this.projects.values()).filter((p) => p.orgId === orgId);
+  }
+  /** Projects of an organization in their on-disk form (what the cloud mirrors). */
+  async listDiskFormByOrg(orgId) {
+    return (await this.listByOrg(orgId)).map(toDiskForm);
+  }
+  /**
+   * Apply a project received from the cloud, in its on-disk form.
+   *
+   * Validated rather than trusted: a peer on another version — or a tampered
+   * doc — must not be able to write arbitrary shapes into `projects.json`.
+   * `activeEnvironmentId` is runtime-only and stays whatever it is locally.
+   * Diff-guarded: an identical project neither saves nor emits (loop-safe).
+   * Returns whether a new local project was created, so the caller can
+   * bootstrap project-local state (e.g. a default environment).
+   */
+  async applyRemoteUpsert(id, fields) {
+    await this.load();
+    const parsed = ProjectSchema.safeParse({ ...fields, id });
+    if (!parsed.success) {
+      console.error("[project-store] Rejected remote project %s:", id, parsed.error.message);
+      return null;
+    }
+    const incoming = toDiskForm(parsed.data);
+    const key = projectKey(parsed.data);
+    const existing = this.projects.get(key);
+    if (existing) {
+      if (JSON.stringify(toDiskForm(existing)) === JSON.stringify(incoming)) {
+        return { project: existing, created: false };
+      }
+      const updated = { ...incoming, activeEnvironmentId: existing.activeEnvironmentId };
+      this.projects.set(key, updated);
+      setProjectVault(updated, vaultFor(updated).root);
+      setProjectServices(updated, updated.serviceIds);
+      await this.save();
+      return { project: updated, created: false };
+    }
+    const project = { ...incoming, activeEnvironmentId: void 0 };
+    this.projects.set(key, project);
+    setProjectVault(project, vaultFor(project).root);
+    setProjectServices(project, project.serviceIds);
+    await this.save();
+    return { project, created: true };
+  }
+  /** Delete a project that was removed on another peer. */
+  async applyRemoteDelete(target) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return false;
+    const { key, project } = found;
+    this.projects.delete(key);
+    await this.save();
+    await this.discardVault(project);
+    await projectPathStore.clear(project);
+    return true;
+  }
+  async addService(target, serviceId) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return null;
+    const { key, project } = found;
+    if (project.serviceIds.includes(serviceId)) return project;
+    const updated = { ...project, serviceIds: [...project.serviceIds, serviceId] };
+    this.projects.set(key, updated);
+    setProjectServices(updated, updated.serviceIds);
+    await this.save();
+    return updated;
+  }
+  async removeService(target, serviceId) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return null;
+    const { key, project } = found;
+    const updated = { ...project, serviceIds: project.serviceIds.filter((id) => id !== serviceId) };
+    recordDetached(project.id, "serviceIds", project.serviceIds, updated.serviceIds);
+    this.projects.set(key, updated);
+    setProjectServices(updated, updated.serviceIds);
+    await this.save();
+    return updated;
+  }
+  async addEnvironment(target, environmentId) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return null;
+    const { key, project } = found;
+    if (project.environmentIds?.includes(environmentId)) return project;
+    const updated = {
+      ...project,
+      environmentIds: [...project.environmentIds ?? [], environmentId]
+    };
+    this.projects.set(key, updated);
+    await this.save();
+    return updated;
+  }
+  async removeEnvironment(target, environmentId) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return null;
+    const { key, project } = found;
+    const updated = {
+      ...project,
+      environmentIds: (project.environmentIds ?? []).filter((id) => id !== environmentId),
+      // Clear activeEnvironmentId if it was the removed environment
+      ...project.activeEnvironmentId === environmentId && { activeEnvironmentId: void 0 }
+    };
+    recordDetached(project.id, "environmentIds", project.environmentIds ?? [], updated.environmentIds);
+    this.projects.set(key, updated);
+    await this.save();
+    return updated;
+  }
+  async setActiveEnvironment(target, environmentId) {
+    await this.load();
+    const found = this.find(target);
+    if (!found) return null;
+    const { key, project } = found;
+    const updated = {
+      ...project,
+      activeEnvironmentId: environmentId
+    };
+    this.projects.set(key, updated);
+    this.unsettled.delete(key);
+    return updated;
+  }
+};
+var projectStore = new ProjectStore();
+registerProjectLoader(() => projectStore.list().then(() => void 0));
+
+export {
+  ensureDataGitignore,
+  conversationSectionStore,
+  holdsRuneyaProject,
+  projectPathStore,
+  LocalProjectRefusedError,
+  LocalProjectExistsError,
+  LocalProjectInMachineRootError,
+  LocalProjectCloudLinkedError,
+  LocalProjectNotFoundError,
+  projectStore
+};
+//# sourceMappingURL=chunk-7QXP4FXD.js.map