@a5c-ai/kradle 5.0.1-staging.3abdf9534c25

package/src/data-plane.js

@@ -0,0 +1,179 @@
+import { giteaIssueSyncPlan, giteaRepositoryIntegrationPlan, orgMemoryRepositoryName } from './gitea-backend.js';
+import { clone, createResource } from './resource-model.js';
+
+
+export function createDefaultGiteaGitBackend({ baseUrl = 'http://kradle-gitea-http:3000', sshDomain = 'kradle-gitea-ssh', owner = 'kradle', webhookBaseUrl = 'http://kradle-webhook-worker' } = {}) {
+  return { type: 'gitea', baseUrl: baseUrl.replace(/\/$/, ''), sshDomain, owner, webhookBaseUrl: webhookBaseUrl.replace(/\/$/, '') };
+}
+
+export function createGiteaRepositoryHosting({ backend = createDefaultGiteaGitBackend(), namespace = 'default', repository, branch = 'main' }) {
+  const owner = backend.owner || namespace;
+  const httpUrl = `${backend.baseUrl}/${owner}/${repository}.git`;
+  const sshUrl = `ssh://git@${backend.sshDomain}/${owner}/${repository}.git`;
+  const webhookUrl = `${backend.webhookBaseUrl}/repositories/${namespace}/${repository}`;
+  return {
+    backend: 'gitea',
+    owner,
+    repository,
+    branch,
+    httpUrl,
+    sshUrl,
+    deployKeyTitle: 'kradle-argocd',
+    organization: { kind: 'Organization', name: owner, delegatedTo: 'Gitea /api/v1/orgs' },
+    sshKeys: { kind: 'SSHKey', scopes: ['user', 'deploy', 'argocd'], delegatedTo: 'Gitea /api/v1/user/keys and /repos/{owner}/{repo}/keys' },
+    permissions: { kind: 'RepositoryPermission', defaultCollaborator: 'write', adminTeam: 'maintainers', delegatedTo: 'Gitea collaborators and team repository APIs' },
+    forgeRecords: { issues: `Gitea /repos/${owner}/${orgMemoryRepositoryName(namespace)}/issues`, pullRequests: 'Gitea /repos/{owner}/{repo}/pulls' },
+    issueSync: giteaIssueSyncPlan({ org: namespace, repositories: [repository] }),
+    webhookUrl,
+    integrationPlan: giteaRepositoryIntegrationPlan({ owner, repo: repository, deployKeyTitle: 'kradle-argocd', permission: 'write', branch, webhookUrl })
+  };
+}
+
+export function stableRepositoryStoreIndex(repositoryName, storeCount) {
+  let hash = 0;
+  for (const character of repositoryName) hash = (hash * 31 + character.charCodeAt(0)) >>> 0;
+  return hash % storeCount;
+}
+
+export class GiteaRepositoryStore {
+  constructor({ name = 'gitea-primary', receivePackReady = true, capacity = 1000 } = {}) {
+    this.name = name;
+    this.receivePackReady = receivePackReady;
+    this.capacity = capacity;
+    this.repositories = new Map();
+    this.objects = new Map();
+    this.searchIndex = new Map();
+  }
+
+  assign(repository) { this.repositories.set(repository.metadata.name, repository); return this; }
+  isReceivePackReady() { return this.receivePackReady; }
+
+  putObject(repository, object) {
+    const objects = this.objects.get(repository) || [];
+    objects.push(object);
+    this.objects.set(repository, objects);
+    return object;
+  }
+
+  index(repository, entry) {
+    const entries = this.searchIndex.get(repository) || [];
+    entries.push(entry);
+    this.searchIndex.set(repository, entries);
+    return entry;
+  }
+
+  snapshot() {
+    return {
+      name: this.name,
+      receivePackReady: this.receivePackReady,
+      capacity: this.capacity,
+      repositories: Object.fromEntries([...this.repositories.entries()].map(([name, resource]) => [name, clone(resource)])),
+      objects: Object.fromEntries([...this.objects.entries()].map(([repository, objects]) => [repository, clone(objects)])),
+      searchIndex: Object.fromEntries([...this.searchIndex.entries()].map(([repository, entries]) => [repository, clone(entries)]))
+    };
+  }
+
+  importSnapshot(snapshot = {}) {
+    this.receivePackReady = snapshot.receivePackReady ?? this.receivePackReady;
+    this.capacity = snapshot.capacity ?? this.capacity;
+    this.repositories = new Map(Object.entries(snapshot.repositories || {}).map(([name, resource]) => [name, clone(resource)]));
+    this.objects = new Map(Object.entries(snapshot.objects || {}).map(([repository, objects]) => [repository, clone(objects)]));
+    this.searchIndex = new Map(Object.entries(snapshot.searchIndex || {}).map(([repository, entries]) => [repository, clone(entries)]));
+    return this;
+  }
+}
+
+export class GiteaGitService {
+  constructor({ controlPlane, stores = [new GiteaRepositoryStore()], gitBackend = createDefaultGiteaGitBackend() }) {
+    if (!controlPlane) throw new Error('GiteaGitService requires a controlPlane');
+    this.controlPlane = controlPlane;
+    this.stores = stores;
+    this.gitBackend = gitBackend.type === 'gitea' ? gitBackend : createDefaultGiteaGitBackend(gitBackend);
+    this.integrationPlans = new Map();
+  }
+
+  snapshot() {
+    return {
+      apiVersion: 'kradle.a5c.ai/v1alpha1',
+      kind: 'GiteaGitServiceSnapshot',
+      backend: clone(this.gitBackend),
+      integrationPlans: Object.fromEntries([...this.integrationPlans.entries()].map(([repository, plan]) => [repository, clone(plan)])),
+      stores: this.stores.map((store) => store.snapshot())
+    };
+  }
+
+  importSnapshot(snapshot = {}) {
+    if (snapshot.backend?.type === 'gitea') this.gitBackend = clone(snapshot.backend);
+    this.integrationPlans = new Map(Object.entries(snapshot.integrationPlans || {}).map(([repository, plan]) => [repository, clone(plan)]));
+    if (!Array.isArray(snapshot.stores)) return this;
+    this.stores = snapshot.stores.map((storeSnapshot) => new GiteaRepositoryStore({
+      name: storeSnapshot.name,
+      receivePackReady: storeSnapshot.receivePackReady,
+      capacity: storeSnapshot.capacity
+    }).importSnapshot(storeSnapshot));
+    return this;
+  }
+
+  route(repositoryName) {
+    const store = this.stores[stableRepositoryStoreIndex(repositoryName, this.stores.length)];
+    const owner = this.gitBackend.owner || 'kradle';
+    return { repositoryName, backend: 'gitea', owner, store: store.name, receivePackReady: store.isReceivePackReady(), httpUrl: `${this.gitBackend.baseUrl}/${owner}/${repositoryName}.git`, sshUrl: `ssh://git@${this.gitBackend.sshDomain}/${owner}/${repositoryName}.git` };
+  }
+
+  createRepository({ name, namespace = 'kradle-org-default', organizationRef = 'default', visibility = 'private' }, user) {
+    const route = this.route(name);
+    const hosting = createGiteaRepositoryHosting({ backend: this.gitBackend, namespace, repository: name });
+    const repository = createResource('Repository', { name, namespace, labels: { gitBackend: 'gitea' } }, {
+      organizationRef,
+      visibility,
+      gitHosting: hosting,
+      storage: { mode: 'gitea', persistentVolumeClaim: 'kradle-gitea-data', owner: hosting.owner, repository: name, httpUrl: hosting.httpUrl, sshUrl: hosting.sshUrl },
+      objectStorage: { lfs: true, artifacts: true },
+      search: { provider: 'zoekt', enabled: false }
+    }, { ready: true, route: { ...route, backend: 'gitea' }, gitHosting: { backend: 'gitea', httpUrl: hosting.httpUrl, sshUrl: hosting.sshUrl, integrationPlan: hosting.integrationPlan } });
+    const created = this.controlPlane.create(repository, user);
+    this.integrationPlans.set(name, hosting.integrationPlan);
+    this.stores.find((store) => store.name === route.store).assign(created);
+    return created;
+  }
+
+  receivePack({ repository, namespace = 'kradle-org-default', ref, oldRev = '0'.repeat(40), newRev, actor }) {
+    const route = this.route(repository);
+    if (!route.receivePackReady) throw new Error(`receive-pack for ${repository} is not ready`);
+    const refPolicies = this.controlPlane.list('RefPolicy', { namespace }).items;
+    const branchProtections = this.controlPlane.list('BranchProtection', { namespace }).items;
+    const deniedByPolicy = refPolicies.find((policy) => (policy.spec.deny || []).some((prefix) => ref.startsWith(prefix)));
+    if (deniedByPolicy) throw new Error(`RefPolicy ${deniedByPolicy.metadata.name} denied ${ref}`);
+    const protectedBranch = branchProtections.find((policy) => (policy.spec.refs || []).includes(ref));
+    const isRepoAdmin = actor.groups?.includes('kradle:repo-admins') || actor.groups?.includes('kradle:platform-engineers');
+    if (protectedBranch && protectedBranch.spec.requirePullRequest && !isRepoAdmin) {
+      throw new Error(`BranchProtection ${protectedBranch.metadata.name} requires pull request for ${ref}`);
+    }
+    const event = { repository, namespace, ref, oldRev, newRev, actor: actor.name, backend: 'gitea', store: route.store, remoteUrl: route.httpUrl, at: new Date().toISOString() };
+    this.controlPlane.events.push({ type: 'git.receive-pack', resource: event, storage: 'gitea' });
+    return event;
+  }
+
+  uploadPack({ repository }) {
+    const route = this.route(repository);
+    return { repository, backend: 'gitea', store: route.store, remoteUrl: route.httpUrl, cacheable: true };
+  }
+
+  recordObject({ repository, namespace = 'default', key, size, mediaType = 'application/octet-stream' }) {
+    const route = this.route(repository);
+    const store = this.stores.find((candidate) => candidate.name === route.store);
+    const object = { repository, namespace, key, size, mediaType, store: route.store, storage: 'object-storage', at: new Date().toISOString() };
+    store.putObject(repository, object);
+    this.controlPlane.events.push({ type: 'git.object-recorded', resource: object, storage: 'object-storage' });
+    return object;
+  }
+
+  enqueueSearchIndex({ repository, namespace = 'default', commit, paths = [] }) {
+    const route = this.route(repository);
+    const store = this.stores.find((candidate) => candidate.name === route.store);
+    const entry = { repository, namespace, commit, paths, store: route.store, provider: 'zoekt', status: 'queued', at: new Date().toISOString() };
+    store.index(repository, entry);
+    this.controlPlane.events.push({ type: 'search.index-queued', resource: entry, storage: 'search-index' });
+    return entry;
+  }
+}

package/src/event-bus.js

@@ -0,0 +1,397 @@
+/**
+ * Module-level event bus for SSE real-event streaming.
+ * Preserves the historical synchronous API while allowing a shared durable
+ * transport underneath it.
+ */
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const EVENT_LOG_DIR = process.env.KRADLE_EVENT_LOG_DIR || join(process.env.HOME || '/tmp', '.kradle', 'events');
+const MAX_EVENTS = 1000;
+const DEFAULT_EVENT_SUBJECT = 'kradle.events';
+const DEFAULT_NATS_STREAM = 'KRADLE_EVENTS';
+
+function ensureLogDir() {
+  try {
+    if (!existsSync(EVENT_LOG_DIR)) mkdirSync(EVENT_LOG_DIR, { recursive: true });
+  } catch (err) {
+    console.warn('[event-bus] failed to create event log directory:', err.message);
+  }
+}
+
+function eventLogFile() {
+  ensureLogDir();
+  return join(EVENT_LOG_DIR, 'events.jsonl');
+}
+
+function persistEvent(event) {
+  try {
+    const logFile = eventLogFile();
+    appendFileSync(logFile, JSON.stringify(event) + '\n');
+    try {
+      const content = readFileSync(logFile, 'utf8');
+      const lines = content.trim().split('\n').filter(Boolean);
+      if (lines.length > MAX_EVENTS) writeFileSync(logFile, lines.slice(-MAX_EVENTS).join('\n') + '\n');
+    } catch (err) {
+      console.warn('[event-bus] failed to truncate event log:', err.message);
+    }
+  } catch (err) {
+    console.warn('[event-bus] failed to persist event:', err.message);
+  }
+}
+
+export function loadPersistedEvents(limit = 100) {
+  try {
+    const logFile = join(EVENT_LOG_DIR, 'events.jsonl');
+    if (!existsSync(logFile)) return [];
+    const content = readFileSync(logFile, 'utf8');
+    const lines = content.trim().split('\n').filter(Boolean);
+    return lines.slice(-limit).map((line) => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function createEventId() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function redactSecretText(value) {
+  return String(value || '')
+    .replace(/([a-z][a-z0-9+.-]*:\/\/)([^:@/\s]+):([^@/\s]+)@/gi, '$1[redacted]:[redacted]@')
+    .replace(/sk-ant-[A-Za-z0-9_-]+/g, '[redacted]')
+    .replace(/sk-[A-Za-z0-9_-]{12,}/g, '[redacted]')
+    .replace(/(token|password|secret|api[_-]?key)=([^&\s]+)/gi, '$1=[redacted]');
+}
+
+function sanitizeBrokerStatus(status) {
+  if (!status || typeof status !== 'object') return status;
+  return Object.fromEntries(Object.entries(status).map(([key, value]) => {
+    if (key === 'reason' || key === 'error' || key === 'url') return [key, redactSecretText(value)];
+    return [key, value];
+  }));
+}
+
+function normalizeEvent(event) {
+  const id = event?.id || createEventId();
+  const timestamp = event?.timestamp || new Date().toISOString();
+
+  return {
+    id,
+    timestamp,
+    ...(event || {}),
+  };
+}
+
+function annotateEvent(event, normalized) {
+  if (!event || typeof event !== 'object') return normalized;
+  if (!Object.prototype.hasOwnProperty.call(event, 'id')) {
+    Object.defineProperty(event, 'id', { value: normalized.id, enumerable: false, configurable: true });
+  }
+  if (!Object.prototype.hasOwnProperty.call(event, 'timestamp')) {
+    Object.defineProperty(event, 'timestamp', { value: normalized.timestamp, enumerable: false, configurable: true });
+  }
+  return event;
+}
+
+function safeDeliver(listener, event) {
+  try {
+    listener(event);
+  } catch (err) {
+    console.warn('[event-bus] subscriber failed:', err?.message || err);
+  }
+}
+
+function decodeBrokerEvent(data) {
+  try {
+    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data || []);
+    return JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    return null;
+  }
+}
+
+export function createNatsJetStreamBrokerClient(options = {}) {
+  const servers = options.url || process.env.KRADLE_EVENT_NATS_URL || process.env.NATS_URL;
+  const subject = options.subject || process.env.KRADLE_EVENT_NATS_SUBJECT || DEFAULT_EVENT_SUBJECT;
+  const stream = options.stream || process.env.KRADLE_EVENT_NATS_STREAM || DEFAULT_NATS_STREAM;
+  let connectionPromise;
+  let jetstreamPromise;
+  let managerPromise;
+  let state = { transport: 'nats-jetstream', status: 'connecting', durable: true, subject, stream };
+
+  async function connection() {
+    if (!connectionPromise) {
+      connectionPromise = import('@nats-io/transport-node')
+        .then(({ connect }) => connect({ servers }))
+        .catch((err) => {
+          state = { ...state, status: 'error', reason: redactSecretText(err?.message || String(err)) };
+          throw err;
+        });
+    }
+    return connectionPromise;
+  }
+
+  async function manager() {
+    if (!managerPromise) {
+      managerPromise = Promise.all([connection(), import('@nats-io/jetstream')]).then(async ([nc, { jetstreamManager }]) => {
+        const jsm = await jetstreamManager(nc);
+        try {
+          await jsm.streams.info(stream);
+        } catch {
+          await jsm.streams.add({ name: stream, subjects: [subject], max_msgs: MAX_EVENTS });
+        }
+        state = { ...state, status: 'ok', reason: undefined };
+        return jsm;
+      });
+    }
+    return managerPromise;
+  }
+
+  async function jetstreamClient() {
+    if (!jetstreamPromise) {
+      jetstreamPromise = Promise.all([connection(), manager(), import('@nats-io/jetstream')]).then(([nc, _jsm, { jetstream }]) => jetstream(nc));
+    }
+    return jetstreamPromise;
+  }
+
+  void manager().catch(() => {});
+
+  return {
+    async publish(eventSubject, event) {
+      const js = await jetstreamClient();
+      const payload = new TextEncoder().encode(JSON.stringify(event));
+      return js.publish(eventSubject || subject, payload, { msgID: event.id }).catch((err) => {
+        state = { ...state, status: 'error', reason: redactSecretText(err?.message || String(err)) };
+        throw err;
+      });
+    },
+
+    subscribe(eventSubject, listener) {
+      let subscription;
+      let active = true;
+      connection().then((nc) => {
+        if (!active) return;
+        subscription = nc.subscribe(eventSubject || subject);
+        (async () => {
+          for await (const message of subscription) {
+            const event = decodeBrokerEvent(message.data);
+            if (event) listener(event);
+          }
+        })().catch((err) => console.warn('[event-bus] NATS subscription failed:', err?.message || err));
+      }).catch((err) => console.warn('[event-bus] NATS connection failed:', err?.message || err));
+      return () => {
+        active = false;
+        try { subscription?.unsubscribe(); } catch {}
+      };
+    },
+
+    async replaySince(eventSubject, cursor, limit = 100) {
+      const jsm = await manager();
+      const info = await jsm.streams.info(stream);
+      const firstSeq = Math.max(info.state.first_seq || 1, (info.state.last_seq || 0) - MAX_EVENTS + 1);
+      const lastSeq = info.state.last_seq || 0;
+      const events = [];
+      for (let seq = firstSeq; seq <= lastSeq && events.length < MAX_EVENTS; seq += 1) {
+        try {
+          const message = await jsm.streams.getMessage(stream, { seq });
+          if (message?.subject !== (eventSubject || subject)) continue;
+          const event = decodeBrokerEvent(message.data);
+          if (event) events.push(event);
+        } catch {}
+      }
+      if (!cursor) return events.slice(-limit);
+      const index = events.findIndex((event) => event.id === cursor);
+      return index < 0 ? [] : events.slice(index + 1, index + 1 + limit);
+    },
+
+    status() {
+      return sanitizeBrokerStatus(state);
+    },
+  };
+}
+
+export function createMemoryEventTransport(options = {}) {
+  const listeners = new Set();
+  const events = Array.isArray(options.initialEvents) ? [...options.initialEvents] : loadPersistedEvents(MAX_EVENTS);
+
+  return {
+    name: 'memory',
+    available: true,
+    required: false,
+
+    publish(event) {
+      const normalized = normalizeEvent(event);
+      const delivered = annotateEvent(event, normalized);
+      events.push(normalized);
+      if (events.length > MAX_EVENTS) events.splice(0, events.length - MAX_EVENTS);
+      persistEvent(normalized);
+      for (const listener of [...listeners]) safeDeliver(listener, delivered);
+      return normalized;
+    },
+
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+
+    replaySince(cursor, limit = 100) {
+      if (!cursor) return events.slice(-limit);
+      const index = events.findIndex((event) => event.id === cursor);
+      if (index < 0) return [];
+      return events.slice(index + 1, index + 1 + limit);
+    },
+
+    status() {
+      return { transport: 'memory', status: 'ok', durable: false };
+    },
+  };
+}
+
+export function createNatsJetStreamEventTransport(options = {}) {
+  const listeners = new Set();
+  const deliveredIds = new Map();
+  const subject = options.subject || process.env.KRADLE_EVENT_NATS_SUBJECT || DEFAULT_EVENT_SUBJECT;
+  const natsUrl = options.url || process.env.KRADLE_EVENT_NATS_URL || process.env.NATS_URL || '';
+  const required = options.required ?? process.env.KRADLE_EVENT_REQUIRE_BROKER === 'true';
+  const brokerClient = options.brokerClient || (natsUrl ? createNatsJetStreamBrokerClient({ url: natsUrl, subject }) : null);
+  let unavailableReason = natsUrl || brokerClient ? null : 'missing-nats-url';
+
+  function publishToBroker(event) {
+    const brokerStatus = sanitizeBrokerStatus(brokerClient?.status?.());
+    if (required && brokerStatus && brokerStatus.status !== 'ok') {
+      throw new Error(brokerStatus.reason || `broker-${brokerStatus.status}`);
+    }
+    if (brokerClient?.publish) return brokerClient.publish(subject, event);
+    unavailableReason = unavailableReason || 'nats-client-not-initialized';
+    if (required) throw new Error(unavailableReason);
+    return null;
+  }
+
+  function deliverOnce(listener, event) {
+    const id = event?.id;
+    if (id) {
+      let ids = deliveredIds.get(listener);
+      if (!ids) {
+        ids = new Set();
+        deliveredIds.set(listener, ids);
+      }
+      if (ids.has(id)) return;
+      ids.add(id);
+      if (ids.size > MAX_EVENTS) ids.delete(ids.values().next().value);
+    }
+    safeDeliver(listener, event);
+  }
+
+  function deliverToLocalListeners(event) {
+    for (const listener of [...listeners]) deliverOnce(listener, event);
+  }
+
+  return {
+    name: 'nats-jetstream',
+    get available() {
+      return Boolean(brokerClient?.publish || natsUrl);
+    },
+    required,
+
+    publish(event) {
+      const normalized = normalizeEvent(event);
+      const delivered = annotateEvent(event, normalized);
+      const published = publishToBroker(normalized);
+      if (required) {
+        return Promise.resolve(published).then(() => {
+          unavailableReason = null;
+          persistEvent(normalized);
+          deliverToLocalListeners(delivered);
+          return normalized;
+        }, (err) => {
+          unavailableReason = redactSecretText(err?.message || String(err));
+          throw err;
+        });
+      }
+      persistEvent(normalized);
+      if (published?.catch) {
+        published.then(() => { unavailableReason = null; }, (err) => { unavailableReason = redactSecretText(err?.message || String(err)); });
+      }
+      deliverToLocalListeners(delivered);
+      return normalized;
+    },
+
+    subscribe(listener) {
+      listeners.add(listener);
+      const unsubscribe = brokerClient?.subscribe?.(subject, (event) => deliverOnce(listener, normalizeEvent(event)));
+      return () => {
+        listeners.delete(listener);
+        deliveredIds.delete(listener);
+        if (typeof unsubscribe === 'function') unsubscribe();
+      };
+    },
+
+    replaySince(cursor, limit = 100) {
+      if (brokerClient?.replaySince) return brokerClient.replaySince(subject, cursor, limit);
+      const persisted = loadPersistedEvents(MAX_EVENTS);
+      if (!cursor) return persisted.slice(-limit);
+      const index = persisted.findIndex((event) => event.id === cursor);
+      return index < 0 ? [] : persisted.slice(index + 1, index + 1 + limit);
+    },
+
+    status() {
+      if (unavailableReason && required) return { transport: 'nats-jetstream', status: 'error', reason: unavailableReason, durable: true };
+      if (brokerClient?.status) return sanitizeBrokerStatus(brokerClient.status());
+      return { transport: 'nats-jetstream', status: unavailableReason ? 'degraded' : 'ok', reason: unavailableReason, durable: true, subject };
+    },
+  };
+}
+
+export function createConfiguredEventTransport(env = process.env) {
+  const wantsNats = env.KRADLE_EVENT_TRANSPORT === 'nats' || env.KRADLE_EVENT_TRANSPORT === 'nats-jetstream' || env.KRADLE_EVENT_NATS_URL || env.NATS_URL;
+  return wantsNats
+    ? createNatsJetStreamEventTransport({ url: env.KRADLE_EVENT_NATS_URL || env.NATS_URL, required: env.KRADLE_EVENT_REQUIRE_BROKER === 'true' })
+    : createMemoryEventTransport();
+}
+
+export function createEventBus(options = {}) {
+  const transport = options.transport || createConfiguredEventTransport(options.env || process.env);
+  const listenerUnsubscribes = new Map();
+
+  return {
+    subscribe(fn) {
+      const unsubscribe = transport.subscribe(fn);
+      listenerUnsubscribes.set(fn, unsubscribe);
+      return unsubscribe;
+    },
+
+    unsubscribe(fn) {
+      const unsubscribe = listenerUnsubscribes.get(fn);
+      if (unsubscribe) unsubscribe();
+      listenerUnsubscribes.delete(fn);
+    },
+
+    emit(event) {
+      return transport.publish(event);
+    },
+
+    emitResourceChange(kind, name, operation) {
+      return this.emit({
+        type: 'resource-change',
+        kind,
+        name,
+        operation,
+        timestamp: new Date().toISOString(),
+      });
+    },
+
+    replaySince(cursor, limit) {
+      return transport.replaySince(cursor, limit);
+    },
+
+    status() {
+      return transport.status();
+    },
+  };
+}
+
+export const globalEventBus = createEventBus();