codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/change-check.js

@@ -0,0 +1,156 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var change_check_exports = {};
+__export(change_check_exports, {
+  checkTheChange: () => checkTheChange
+});
+module.exports = __toCommonJS(change_check_exports);
+var import_node_child_process = require("node:child_process");
+var import_conformity_gate = require("./conformity-gate");
+var import_workstream_imports = require("./workstream-imports");
+var import_rules_at = require("./rules-at");
+var import_rule_changes = require("./rule-changes");
+var import_rule_approvals = require("./rule-approvals");
+var import_rule_scope = require("./rule-scope");
+var import_rule_baseline = require("./rule-baseline");
+var import_architecture_rules = require("./architecture-rules");
+var import_pipeline = require("./pipeline");
+var import_database = require("./database");
+var import_git_safety = require("./git-safety");
+var import_check_runs = require("./check-runs");
+var import_test_runs = require("./task-records/test-runs");
+var import_shared_state = require("./task-records/shared-state");
+var import_check_words = require("../../shared/lib/check-words");
+async function checkTheChange(input) {
+  const { root, paths, base, strict, by, ranIn } = input;
+  const scope = (0, import_rule_scope.parseScope)(input.scope);
+  const ref = base ?? "HEAD";
+  let since = null;
+  if ((0, import_git_safety.isSafeGitRef)(ref)) {
+    try {
+      since = (0, import_node_child_process.execFileSync)("git", ["-C", root, "rev-parse", "--verify", "--quiet", `${ref}^{commit}`], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+    } catch {
+      since = null;
+    }
+  }
+  if (base !== void 0 && !since) {
+    return { error: `${base} is not a commit in this repository (a shallow clone? fetch the base first).` };
+  }
+  let judgeBy;
+  let rulebook = [];
+  const notes = [];
+  if (since) {
+    const atBase = await (0, import_rules_at.rulesAt)(root, since);
+    if (atBase) {
+      judgeBy = (0, import_rule_scope.scopeRules)(atBase.rules, scope);
+      rulebook = (0, import_rule_changes.diffRules)(atBase.rules, (0, import_architecture_rules.rulesOf)(root), (0, import_architecture_rules.edgesIfLoaded)(root, input.activeProject, import_database.getDependencyEdges, void 0, atBase.rules) ?? []).filter((c2) => !scope || c2.before && (0, import_rule_scope.inScope)(c2.before, scope) || c2.after && (0, import_rule_scope.inScope)(c2.after, scope));
+      if (rulebook.some((c2) => c2.effect === "loosens")) {
+        const approvals = (0, import_rule_approvals.approvalsHere)(root);
+        const keys = (0, import_rule_approvals.keysAt)(root, since);
+        try {
+          for (const c2 of rulebook) if (c2.effect === "loosens") c2.approval = (0, import_rule_approvals.approvalFor)(root, c2, approvals, keys, since);
+        } finally {
+          keys.done();
+        }
+      }
+    } else {
+      notes.push(`\u26A0 The rules at ${since.slice(0, 7)} could not be read, so this change was judged by its own rules. Fetch the base with its history.`);
+    }
+    if (!scope || input.pipeline) {
+      const was = await (0, import_pipeline.pipelineAt)(root, since);
+      const now = (0, import_pipeline.readPipeline)(root);
+      if (now?.problems.length) notes.push(`\u26A0 ${now.problems.join("; ")}`);
+      const changes = (0, import_pipeline.diffPipeline)(was?.pipeline ?? null, now?.pipeline ?? null);
+      if (changes.some((c2) => c2.effect === "loosens")) {
+        const approvals = (0, import_rule_approvals.approvalsHere)(root);
+        const keys = (0, import_rule_approvals.keysAt)(root, since);
+        try {
+          for (const c2 of changes) if (c2.effect === "loosens") c2.approval = (0, import_rule_approvals.approvalFor)(root, c2, approvals, keys, since);
+        } finally {
+          keys.done();
+        }
+      }
+      rulebook = [...rulebook, ...changes];
+    }
+  }
+  let ratchetFound = [];
+  const baseBaseline = since ? (0, import_rule_baseline.baselineAt)(root, since) : null;
+  const headBaseline = (0, import_rule_baseline.readBaseline)(root);
+  if (baseBaseline || headBaseline) {
+    const judged = judgeBy ?? (0, import_rule_scope.scopeRules)((0, import_architecture_rules.rulesOf)(root), scope);
+    const edges = (0, import_architecture_rules.edgesIfLoaded)(root, input.activeProject, import_database.getDependencyEdges);
+    if (edges) {
+      const strengthOf = new Map(judged.map((r) => [r.id, r.strength]));
+      const ids = new Set(judged.map((r) => r.id));
+      ratchetFound = (0, import_rule_baseline.ratchet)(baseBaseline, headBaseline, judged, edges).filter((f) => ids.has(f.rule) || f.kind === "grew").map((f) => ({ ...f, strength: strengthOf.get(f.rule) ?? "block" }));
+    } else {
+      notes.push("\u26A0 The rules' baseline was not checked: this project's imports are not loaded here.");
+    }
+  }
+  const c = await (0, import_conformity_gate.checkChanges)(root, paths, input.checkCriterion, (files) => (0, import_workstream_imports.ruleImports)(root, files, since, judgeBy ?? (scope ? (0, import_rule_scope.scopeRules)((0, import_architecture_rules.rulesOf)(root), scope) : void 0)), rulebook, notes, strict === true, scope !== null, ratchetFound);
+  const failing = new Set(c.says);
+  const code = (0, import_test_runs.codeAt)(root);
+  const findings = c.rules.map((r) => ({
+    rule: r.rule,
+    suite: r.suite ?? "architecture",
+    path: r.path,
+    imports: r.imports,
+    strength: r.strength,
+    failing: failing.has(`\u2717 ${(0, import_check_words.findingLine)(r)}`),
+    words: r.words,
+    fix: r.fix ?? null
+  }));
+  const runId = (0, import_check_runs.recordCheckRun)({
+    projectRoot: root,
+    at: Date.now(),
+    by,
+    ranIn,
+    commit: code.commit,
+    dirty: code.dirty,
+    base: base ?? null,
+    rulebook: judgeBy ? since : null,
+    scope: scope ? (0, import_rule_scope.scopeWords)(scope) : null,
+    strict: strict === true,
+    outcome: { ok: c.ok, files: c.files.length, blocks: c.says.length, warns: findings.filter((f) => !f.failing).length },
+    says: c.says.slice(0, 200),
+    findings: findings.slice(0, 1e3)
+  }, { writer: (0, import_shared_state.writerId)(), name: (0, import_shared_state.writerName)(root) });
+  return { result: {
+    ok: c.ok,
+    says: c.says,
+    files: c.files.length,
+    run: runId,
+    breakpoints: c.breakpoints,
+    tests: c.tests,
+    criteria: c.criteria.map((x) => ({ item_uid: x.itemUid, task: x.task, criterion: x.criterion, findings: x.findings })),
+    docs: c.docs.map((d) => ({ uid: d.uid, title: d.title, slug: d.slug, verified_at: d.verifiedAt, files: d.files })),
+    rules: c.rules.map((r) => ({ path: r.path, imports: r.imports, rule: r.rule, words: r.words, because: r.because, strength: r.strength, suite: r.suite ?? "architecture", fix: r.fix ?? null, ...r.line ? { line_found: r.line } : {} })),
+    // C8: the rules judged by, so a suite can say how many hold.
+    // B5: an agent rule is a review's to judge, not this check's: it is not said to hold.
+    checked: (judgeBy ?? (0, import_rule_scope.scopeRules)((0, import_architecture_rules.rulesOf)(root), scope)).filter((r) => r.kind !== "agent").map((r) => ({ rule: r.id, suite: r.suite ?? "architecture", strength: r.strength })),
+    rulebook: c.rulebook.map((r) => ({ rule: r.rule, change: r.change, effect: r.effect, allowed: r.allowed, forbidden: r.forbidden, words: (0, import_rule_changes.changeWords)(r), ...r.approval ? { approval: r.approval } : {} })),
+    notes: c.notes,
+    ...c.ratchet.length ? { ratchet: c.ratchet } : {},
+    ...scope ? { scope: (0, import_rule_scope.scopeWords)(scope) } : {},
+    ...c.rulesChecked ? {} : { rules_note: "The architecture rules were not checked: this project's imports are not loaded here. Open the project, or run `codetrellis start` in it." }
+  } };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkTheChange
+});

package/src/backend/services/channel-dispatcher-service.js

@@ -0,0 +1,235 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var channel_dispatcher_service_exports = {};
+__export(channel_dispatcher_service_exports, {
+  dispatchChannelEvent: () => dispatchChannelEvent,
+  startChannelDispatcher: () => startChannelDispatcher,
+  stopChannelDispatcher: () => stopChannelDispatcher
+});
+module.exports = __toCommonJS(channel_dispatcher_service_exports);
+var _lazy___plan_service = __toESM(require("./plan-service"));
+var import_channel_event_service = require("./channel-event-service");
+var import_settings_service = require("./settings-service");
+var import_webhook_egress = require("./webhook-egress");
+var import_project_config_service = require("./project-config-service");
+var import_plan_service = require("./plan-service");
+var import_push_notification_service = require("./push-notification-service");
+let broadcastFn = null;
+let staleSweepTimer = null;
+const firedNotifications = /* @__PURE__ */ new Set();
+function startChannelDispatcher(broadcast) {
+  broadcastFn = broadcast;
+  if (staleSweepTimer) return;
+  staleSweepTimer = setInterval(() => {
+    sweepStaleEvents().catch((err) => console.warn("[ChannelDispatcher] stale sweep failed:", err));
+  }, 3e4);
+  if (typeof staleSweepTimer.unref === "function") staleSweepTimer.unref();
+}
+function stopChannelDispatcher() {
+  if (staleSweepTimer) {
+    clearInterval(staleSweepTimer);
+    staleSweepTimer = null;
+  }
+  firedNotifications.clear();
+}
+async function dispatchChannelEvent(event) {
+  (0, import_push_notification_service.pushForChannelEvent)(event).catch(
+    (err) => console.warn("[ChannelDispatcher] push notification failed:", err)
+  );
+  const projectRoot = projectRootForEvent(event);
+  if (!projectRoot) return;
+  const rules = (0, import_project_config_service.matchChannelRoutingRules)(projectRoot, event);
+  await Promise.all(
+    rules.filter((r) => r.when.minAgeMs === void 0).map((r) => fireRule(r, event))
+  );
+}
+async function sweepStaleEvents() {
+  const eligiblePlans = listEligiblePlansForSweep();
+  if (eligiblePlans.length === 0) return;
+  const now = Date.now();
+  for (const { planUid, projectRoot, rules } of eligiblePlans) {
+    const openEvents = (0, import_channel_event_service.listChannelEvents)(planUid, { status: "open", limit: 500 });
+    for (const event of openEvents) {
+      for (const rule of rules) {
+        if (rule.when.minAgeMs === void 0) continue;
+        if (!matchesWithoutAge(rule, event)) continue;
+        const age = now - event.createdAt;
+        if (age < rule.when.minAgeMs) continue;
+        const key = notificationKey(rule, event);
+        if (firedNotifications.has(key)) continue;
+        firedNotifications.add(key);
+        await fireRule(rule, event, projectRoot);
+      }
+    }
+  }
+}
+async function fireRule(rule, event, projectRootHint) {
+  try {
+    if (rule.notify.target === "webhook") {
+      await fireWebhook(rule, event);
+    } else if (rule.notify.target === "in-app-toast") {
+      fireToast(rule, event, projectRootHint);
+    }
+  } catch (err) {
+    console.warn(`[ChannelDispatcher] rule ${rule.id ?? "(unnamed)"} failed:`, err);
+  }
+}
+async function fireWebhook(rule, event) {
+  if (rule.notify.target !== "webhook") return;
+  const url = rule.notify.url;
+  let target;
+  try {
+    const webhookSettings = (0, import_settings_service.getSettings)().webhooks;
+    target = await (0, import_webhook_egress.resolveWebhookTarget)(url, webhookSettings.allowedHosts, {
+      allowLoopback: webhookSettings.allowLoopback
+    });
+  } catch (err) {
+    if (err instanceof import_webhook_egress.WebhookBlocked) {
+      console.warn(`[ChannelDispatcher] webhook blocked \u2014 ${err.message}`);
+      broadcastFn?.("channel-webhook-blocked", {
+        ruleId: rule.id ?? null,
+        url,
+        reason: err.message
+      });
+      return;
+    }
+    throw err;
+  }
+  const payload = {
+    rule: { id: rule.id, description: rule.description },
+    event: {
+      uid: event.uid,
+      planUid: event.planUid,
+      itemUid: event.itemUid,
+      eventType: event.eventType,
+      status: event.status,
+      author: event.author,
+      authorType: event.authorType,
+      agentModel: event.agentModel,
+      respondsTo: event.respondsTo,
+      payload: event.payload,
+      createdAt: event.createdAt,
+      updatedAt: event.updatedAt
+    },
+    firedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const headers = {
+    "content-type": "application/json",
+    ...rule.notify.headers ?? {}
+  };
+  const body = JSON.stringify(payload);
+  const maxAttempts = 2;
+  let lastErr = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const res = await (0, import_webhook_egress.postWebhookJson)(target, headers, body, 5e3);
+      if (res.redirected) {
+        console.warn(`[ChannelDispatcher] webhook ${url} redirected (${res.status}) \u2014 refusing to follow`);
+        return;
+      }
+      if (res.status >= 200 && res.status < 300) return;
+      if (res.status < 500) {
+        console.warn(`[ChannelDispatcher] webhook ${url} returned ${res.status} (no retry)`);
+        return;
+      }
+      lastErr = new Error(`HTTP ${res.status}`);
+    } catch (err) {
+      lastErr = err;
+    }
+    if (attempt < maxAttempts) {
+      await new Promise((r) => setTimeout(r, 500 * attempt));
+    }
+  }
+  console.warn(`[ChannelDispatcher] webhook ${url} failed after ${maxAttempts} attempts:`, lastErr);
+}
+function fireToast(rule, event, projectRootHint) {
+  if (!broadcastFn) return;
+  if (rule.notify.target !== "in-app-toast") return;
+  broadcastFn("channel-toast-elevated", {
+    ruleId: rule.id ?? null,
+    description: rule.description ?? null,
+    tone: rule.notify.tone ?? "info",
+    sticky: !!rule.notify.sticky,
+    projectRoot: projectRootHint ?? projectRootForEvent(event),
+    event: {
+      uid: event.uid,
+      planUid: event.planUid,
+      itemUid: event.itemUid,
+      eventType: event.eventType,
+      status: event.status,
+      // Attribution must travel with the toast payload — the frontend
+      // composes the fallback title as "<eventType> · <author>" when
+      // the rule has no description. Without these the title falls
+      // back to the bland "Channel: stuck" every time.
+      author: event.author,
+      authorType: event.authorType,
+      agentModel: event.agentModel,
+      payload: event.payload
+    }
+  });
+}
+function projectRootForEvent(event) {
+  const plan = (0, import_plan_service.getPlan)(event.planUid);
+  if (!plan) return null;
+  return plan.projectPath || null;
+}
+function matchesWithoutAge(rule, event) {
+  const w = rule.when;
+  if (w.eventType && w.eventType !== event.eventType) return false;
+  if (w.status && w.status !== event.status) return false;
+  if (w.planUid && w.planUid !== event.planUid) return false;
+  if (w.itemUid && w.itemUid !== event.itemUid) return false;
+  return true;
+}
+function notificationKey(rule, event) {
+  return `${rule.id ?? "_"}:${event.uid}`;
+}
+function listEligiblePlansForSweep() {
+  const { listPlans } = _lazy___plan_service;
+  const plans = listPlans();
+  const result = [];
+  const cache = /* @__PURE__ */ new Map();
+  for (const plan of plans) {
+    if (!plan.projectPath) continue;
+    let rules = cache.get(plan.projectPath);
+    if (!rules) {
+      rules = (0, import_project_config_service.listChannelRoutingRules)(plan.projectPath).filter((r) => r.when.minAgeMs !== void 0);
+      cache.set(plan.projectPath, rules);
+    }
+    if (rules.length > 0) {
+      result.push({ planUid: plan.uid, projectRoot: plan.projectPath, rules });
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dispatchChannelEvent,
+  startChannelDispatcher,
+  stopChannelDispatcher
+});

package/src/backend/services/channel-event-file-service.js

@@ -0,0 +1,125 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var channel_event_file_service_exports = {};
+__export(channel_event_file_service_exports, {
+  channelsDirFor: () => channelsDirFor,
+  discoverChannelEventFiles: () => discoverChannelEventFiles,
+  exportChannelEvent: () => exportChannelEvent,
+  importChannelEvent: () => importChannelEvent,
+  isChannelEventFile: () => isChannelEventFile,
+  removeChannelEventFile: () => removeChannelEventFile
+});
+module.exports = __toCommonJS(channel_event_file_service_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_yaml = require("yaml");
+var import_self_write_tracker = require("./self-write-tracker");
+var import_plan_service = require("./plan-service");
+var import_plan_file_service = require("./plan-file-service");
+var import_channel_event_service = require("./channel-event-service");
+var import_plans_home = require("./plans-home");
+const CHANNELS_DIR_NAME = "channels";
+function channelsDirFor(planUid, projectRoot) {
+  const linked = (0, import_plan_file_service.getLinkedPlanDir)(planUid, projectRoot);
+  if (linked) return import_node_path.default.join(linked, CHANNELS_DIR_NAME);
+  const plan = (0, import_plan_service.getPlan)(planUid);
+  const slug = plan ? (0, import_plan_file_service.makePlanSlug)(plan) : planUid;
+  return import_node_path.default.join((0, import_plans_home.plansHome)(projectRoot) ?? projectRoot, ".codetrellis", "plans", slug, CHANNELS_DIR_NAME);
+}
+function exportChannelEvent(event, projectRoot) {
+  const dir = channelsDirFor(event.planUid, projectRoot);
+  ensureDir(dir);
+  const filePath = import_node_path.default.join(dir, `${event.uid}.yaml`);
+  const record = (0, import_channel_event_service.eventToManifest)(event);
+  writeAtomic(filePath, (0, import_yaml.stringify)(record));
+  return filePath;
+}
+function removeChannelEventFile(eventUid, planUid, projectRoot) {
+  const filePath = import_node_path.default.join(channelsDirFor(planUid, projectRoot), `${eventUid}.yaml`);
+  if (!import_node_fs.default.existsSync(filePath)) return false;
+  (0, import_self_write_tracker.stampSelfWrite)(filePath);
+  import_node_fs.default.unlinkSync(filePath);
+  return true;
+}
+function importChannelEvent(filePath, planDir) {
+  if (!import_node_fs.default.existsSync(filePath)) return null;
+  const planUid = readPlanUidFromDir(planDir);
+  if (!planUid) {
+    console.warn(`[ChannelEvents] Could not resolve plan UID from ${planDir} \u2014 skipping import.`);
+    return null;
+  }
+  try {
+    const raw = (0, import_yaml.parse)(import_node_fs.default.readFileSync(filePath, "utf-8"));
+    if (!raw || typeof raw !== "object") return null;
+    const record = raw;
+    if (!record.uid || !record.eventType || !record.payload) return null;
+    const input = (0, import_channel_event_service.manifestToEventInput)(planUid, record);
+    return (0, import_channel_event_service.postChannelEvent)(input);
+  } catch (err) {
+    console.warn(`[ChannelEvents] Failed to import ${filePath}:`, err);
+    return null;
+  }
+}
+function readPlanUidFromDir(planDir) {
+  const planYaml = import_node_path.default.join(planDir, "plan.yaml");
+  if (!import_node_fs.default.existsSync(planYaml)) return null;
+  try {
+    const raw = (0, import_yaml.parse)(import_node_fs.default.readFileSync(planYaml, "utf-8"));
+    if (raw && typeof raw === "object" && typeof raw.uid === "string") {
+      return raw.uid;
+    }
+  } catch {
+  }
+  return null;
+}
+function discoverChannelEventFiles(planDir) {
+  const dir = import_node_path.default.join(planDir, CHANNELS_DIR_NAME);
+  if (!import_node_fs.default.existsSync(dir)) return [];
+  return import_node_fs.default.readdirSync(dir).filter((f) => f.endsWith(".yaml")).map((f) => import_node_path.default.join(dir, f));
+}
+function isChannelEventFile(filePath) {
+  return import_node_path.default.basename(import_node_path.default.dirname(filePath)) === CHANNELS_DIR_NAME && filePath.endsWith(".yaml");
+}
+function ensureDir(dir) {
+  if (!import_node_fs.default.existsSync(dir)) import_node_fs.default.mkdirSync(dir, { recursive: true });
+}
+function writeAtomic(filePath, content) {
+  const tmp = `${filePath}.tmp`;
+  import_node_fs.default.writeFileSync(tmp, content, "utf-8");
+  import_node_fs.default.renameSync(tmp, filePath);
+  (0, import_self_write_tracker.stampSelfWrite)(filePath);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  channelsDirFor,
+  discoverChannelEventFiles,
+  exportChannelEvent,
+  importChannelEvent,
+  isChannelEventFile,
+  removeChannelEventFile
+});