khala-cli 0.3.0

package/dist/chunk-GO5DD2TR.mjs

@@ -0,0 +1,442 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+
+// ../contracts/src/delivery/decode.ts
+var MAX_IDENTIFIER_BYTES = 512;
+var DecodeFailure = class extends Error {
+  code;
+  field;
+  constructor(field, code) {
+    super(`${field || "<root>"}: ${code}`);
+    this.name = "DecodeFailure";
+    this.code = code;
+    this.field = field;
+  }
+};
+function fail(field, code) {
+  throw new DecodeFailure(field, code);
+}
+function decodeWith(read) {
+  try {
+    return { ok: true, value: read() };
+  } catch (error) {
+    if (error instanceof DecodeFailure) return { ok: false, code: error.code, field: error.field };
+    return { ok: false, code: "invalid_field", field: "" };
+  }
+}
+function utf8Length(value) {
+  let bytes = 0;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint < 128) bytes += 1;
+    else if (codePoint < 2048) bytes += 2;
+    else if (codePoint < 65536) bytes += 3;
+    else bytes += 4;
+  }
+  return bytes;
+}
+function isWellFormed(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) return false;
+      index += 1;
+    } else if (unit >= 56320 && unit <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+var CONTROL = /[\u0000-\u001f\u007f-\u009f]/;
+function identifier(input, field) {
+  if (typeof input !== "string") fail(field, "invalid_field");
+  if (!isWellFormed(input) || input.length === 0 || CONTROL.test(input)) fail(field, "invalid_field");
+  if (utf8Length(input) > MAX_IDENTIFIER_BYTES) fail(field, "limit_exceeded");
+  return input;
+}
+function literal(input, field, allowed) {
+  if (!allowed.includes(input)) fail(field, "invalid_field");
+  return input;
+}
+
+// ../contracts/src/delivery/ids.ts
+function readId(input, field) {
+  return identifier(input, field);
+}
+var idDecoder = () => (input) => decodeWith(() => readId(input, ""));
+var decodeOwnerId = idDecoder();
+var decodeParticipantId = idDecoder();
+var decodeDeviceId = idDecoder();
+var decodeBindingId = idDecoder();
+var decodeRoomId = idDecoder();
+var decodeEventId = idDecoder();
+var decodeCommandId = idDecoder();
+var decodeReleaseId = idDecoder();
+var decodeReceiptId = idDecoder();
+var decodeAuthorizationId = idDecoder();
+var decodeOperationId = idDecoder();
+var decodeCausalRootId = idDecoder();
+
+// ../contracts/src/delivery/listening-mode.ts
+var LISTENING_MODES = ["steer", "sync", "async"];
+function decodeListeningMode(input) {
+  return decodeWith(() => literal(input, "", LISTENING_MODES));
+}
+
+// ../contracts/src/messaging/decode.ts
+var MAX_IDENTIFIER_BYTES2 = 512;
+var DecodeFailure2 = class extends Error {
+  path;
+  code;
+  constructor(path, code) {
+    super(`${path || "<root>"}: ${code}`);
+    this.name = "DecodeFailure";
+    this.path = path;
+    this.code = code;
+  }
+};
+function fail2(path, code) {
+  throw new DecodeFailure2(path, code);
+}
+function decodeWith2(read) {
+  try {
+    return { ok: true, value: read() };
+  } catch (error) {
+    if (error instanceof DecodeFailure2) return { ok: false, error: { path: error.path, code: error.code } };
+    throw error;
+  }
+}
+var join = (path, key) => typeof key === "number" ? `${path}[${key}]` : path ? `${path}.${key}` : key;
+function object2(input, path, keys) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) fail2(path, "not_object");
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype !== Object.prototype && prototype !== null) fail2(path, "not_object");
+  const record2 = input;
+  for (const key of Object.keys(record2)) if (!keys.includes(key)) fail2(join(path, key), "unknown_field");
+  for (const key of keys) if (!Object.hasOwn(record2, key)) fail2(join(path, key), "missing_field");
+  return { path, field: (key) => record2[key], at: (key) => join(path, key) };
+}
+function array(input, path) {
+  if (!Array.isArray(input)) fail2(path, "wrong_type");
+  return input;
+}
+function elementPath(path, index) {
+  return join(path, index);
+}
+function utf8Length2(value) {
+  let bytes = 0;
+  for (const char of value) {
+    const code = char.codePointAt(0) ?? 0;
+    bytes += code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+  }
+  return bytes;
+}
+function isWellFormed2(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) return false;
+      index += 1;
+    } else if (unit >= 56320 && unit <= 57343) return false;
+  }
+  return true;
+}
+var CONTROL2 = /[\u0000-\u001f\u007f-\u009f]/;
+var INVISIBLE = /[\u061c\u200b\u200e\u200f\u202a-\u202e\u2060\u2066-\u2069\ufeff]/;
+function text(input, path, maxBytes) {
+  if (typeof input !== "string") fail2(path, "wrong_type");
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) fail2(path, "invalid_limits");
+  if (!isWellFormed2(input)) fail2(path, "malformed_unicode");
+  if (utf8Length2(input) > maxBytes) fail2(path, "too_long");
+  if (input.includes("\0")) fail2(path, "control_character");
+  return input;
+}
+function label(input, path, maxBytes) {
+  const value = text(input, path, maxBytes);
+  if (CONTROL2.test(value)) fail2(path, "control_character");
+  return value;
+}
+function displayText(input, path, maxBytes) {
+  const value = label(input, path, maxBytes);
+  if (INVISIBLE.test(value)) fail2(path, "control_character");
+  return value;
+}
+function identifier2(input, path) {
+  const value = label(input, path, MAX_IDENTIFIER_BYTES2);
+  if (value.length === 0) fail2(path, "empty");
+  return value;
+}
+function nullable2(input, read) {
+  return input === null ? null : read(input);
+}
+function literal2(input, path, allowed) {
+  if (!allowed.includes(input)) fail2(path, typeof input === typeof allowed[0] ? "invalid_value" : "wrong_type");
+  return input;
+}
+function version2(input, path) {
+  if (input !== 1) fail2(path, "unsupported_version");
+  return 1;
+}
+function safeInteger2(input, path) {
+  if (typeof input !== "number") fail2(path, "wrong_type");
+  if (!Number.isSafeInteger(input)) fail2(path, "unsafe_integer");
+  if (input < 0) fail2(path, "invalid_value");
+  return input;
+}
+var UTC_TIMESTAMP = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?Z$/;
+function utcTimestamp2(input, path) {
+  if (typeof input !== "string") fail2(path, "wrong_type");
+  const match = UTC_TIMESTAMP.exec(input);
+  if (!match) fail2(path, "invalid_value");
+  const [year, month, day, hour, minute, second] = match.slice(1).map(Number);
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(hour, minute, second, 0);
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day || date.getUTCHours() !== hour || date.getUTCMinutes() !== minute || date.getUTCSeconds() !== second) fail2(path, "invalid_value");
+  return input;
+}
+
+// ../contracts/src/messaging/agent-names.ts
+var MAX_AGENT_NAME_BYTES = 80;
+var unsafe = /[\u0000-\u001f\u007f-\u009f\u061c\u200b-\u200f\u2028-\u202e\u2060-\u2069\ufeff]/u;
+var reserved = /\b(?:admin(?:istrator)?|system|khala|moderator|owner|human|security|support|official)\b/iu;
+function validateAgentName(input) {
+  if (typeof input !== "string") return { ok: false, error: "blank" };
+  const name = input.trim().normalize("NFC");
+  if (!name) return { ok: false, error: "blank" };
+  if (unsafe.test(name)) return { ok: false, error: "invalid_characters" };
+  if (new TextEncoder().encode(name).byteLength > MAX_AGENT_NAME_BYTES) return { ok: false, error: "too_long" };
+  if (reserved.test(name.normalize("NFKC"))) return { ok: false, error: "reserved" };
+  return { ok: true, name };
+}
+
+// ../contracts/src/m1/agent-join.ts
+var HARNESSES = ["claude", "codex"];
+var M1_LABEL_MAX_BYTES = 512;
+var agentConfirmPagePath = (id) => `/agent/confirm?joinId=${encodeURIComponent(id)}`;
+function readHarness(input, path) {
+  return literal2(input, path, HARNESSES);
+}
+function readHttpUrl(input, path) {
+  if (typeof input !== "string") fail2(path, "wrong_type");
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    fail2(path, "invalid_value");
+  }
+  if (url.username || url.password || url.hash || !(url.protocol === "https:" || url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) fail2(path, "invalid_value");
+  return input;
+}
+function readMatrixUserId(input, path) {
+  const value = identifier2(input, path);
+  if (!/^@[^\s:]+:\S+$/u.test(value)) fail2(path, "invalid_value");
+  return value;
+}
+function readRoomId(input, path) {
+  const value = identifier2(input, path);
+  if (!/^!\S+$/u.test(value)) fail2(path, "invalid_value");
+  return value;
+}
+
+// ../contracts/src/m1/listening-mode.ts
+var LISTENING_MODE_COMMAND_TYPE = "com.khala.listening_mode.v1";
+var LISTENING_MODE_MEMBER_KEY = "com.khala.listening_mode";
+var DEFAULT_LISTENING_MODE = "sync";
+function decodeListeningModeCommand(input) {
+  return decodeWith2(() => {
+    const r = object2(input, "", ["v", "agent", "mode"]);
+    return {
+      v: version2(r.field("v"), r.at("v")),
+      agent: readMatrixUserId(r.field("agent"), r.at("agent")),
+      mode: literal2(r.field("mode"), r.at("mode"), LISTENING_MODES)
+    };
+  });
+}
+function memberListeningMode(content) {
+  const value = typeof content === "object" && content !== null ? content[LISTENING_MODE_MEMBER_KEY] : void 0;
+  const decoded = decodeListeningMode(value);
+  return decoded.ok ? decoded.value : DEFAULT_LISTENING_MODE;
+}
+
+// ../contracts/src/m1/channel-event.ts
+var CHANNEL_EVENT_TYPE = "com.khala.event.v1";
+var CHANNEL_EVENT_STATUSES = ["info", "pending", "success", "failure", "attention"];
+var MAX_CHANNEL_EVENT_BYTES = 4096;
+function record(input, path) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) fail2(path, "not_object");
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype !== Object.prototype && prototype !== null) fail2(path, "not_object");
+  const value = input;
+  return {
+    has: (key) => Object.hasOwn(value, key) && value[key] !== void 0,
+    field: (key) => Object.hasOwn(value, key) ? value[key] : fail2(path ? `${path}.${key}` : key, "missing_field"),
+    at: (key) => path ? `${path}.${key}` : key
+  };
+}
+function nonempty(value, path) {
+  if (!value.length) fail2(path, "empty");
+  return value;
+}
+function display(input, path, maxBytes, maxPoints) {
+  const value = nonempty(displayText(input, path, maxBytes), path);
+  if ([...value].length > maxPoints) fail2(path, "too_long");
+  return value;
+}
+function matching(value, path, pattern) {
+  if (!pattern.test(value)) fail2(path, "invalid_value");
+  return value;
+}
+function safely(read) {
+  try {
+    return read();
+  } catch {
+    return { ok: false, error: { path: "", code: "invalid_value" } };
+  }
+}
+function decodeChannelEvent(raw) {
+  return safely(() => decodeWith2(() => {
+    let serialized;
+    try {
+      serialized = JSON.stringify(raw);
+    } catch {
+      fail2("", "invalid_value");
+    }
+    if (serialized !== void 0 && utf8Length2(serialized) > MAX_CHANNEL_EVENT_BYTES) fail2("", "too_long");
+    const r = record(raw, "");
+    const v = version2(r.field("v"), "v");
+    const kind = matching(nonempty(label(r.field("kind"), "kind", 128), "kind"), "kind", /^[a-z0-9_-]+(\.[a-z0-9_-]+)*$/);
+    const summary = display(r.field("summary"), "summary", 800, 200);
+    if (!summary.trim()) fail2("summary", "empty");
+    const body = label(r.field("body"), "body", 1024);
+    return {
+      v,
+      kind,
+      summary,
+      body,
+      ...r.has("status") ? { status: literal2(r.field("status"), "status", CHANNEL_EVENT_STATUSES) } : {},
+      ...r.has("subject") ? { subject: readSubject(r.field("subject")) } : {},
+      ...r.has("actor") ? { actor: display(r.field("actor"), "actor", 256, 64) } : {},
+      ...r.has("url") ? { url: readUrl(r.field("url")) } : {},
+      ...r.has("occurred_at") ? { occurred_at: utcTimestamp2(r.field("occurred_at"), "occurred_at") } : {},
+      ...r.has("source") ? { source: readSource(r.field("source")) } : {},
+      ...r.has("key") ? { key: nonempty(label(r.field("key"), "key", 200), "key") } : {}
+    };
+  }));
+}
+function readSubject(input) {
+  const r = record(input, "subject");
+  let pr;
+  if (r.has("pr")) {
+    pr = safeInteger2(r.field("pr"), r.at("pr"));
+    if (pr === 0) fail2(r.at("pr"), "invalid_value");
+  }
+  let branch;
+  if (r.has("branch")) {
+    branch = nonempty(label(r.field("branch"), r.at("branch"), 255), r.at("branch"));
+    if (branch.startsWith("refs/")) fail2(r.at("branch"), "invalid_value");
+  }
+  return {
+    ...r.has("ticket") ? { ticket: display(r.field("ticket"), r.at("ticket"), 256, 64) } : {},
+    ...pr !== void 0 ? { pr } : {},
+    ...branch !== void 0 ? { branch } : {},
+    ...r.has("repo") ? { repo: matching(label(r.field("repo"), r.at("repo"), 140), r.at("repo"), /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/) } : {},
+    ...r.has("sha") ? { sha: matching(label(r.field("sha"), r.at("sha"), 64), r.at("sha"), /^[0-9a-f]{7,64}$/) } : {}
+  };
+}
+function readSource(input) {
+  const r = record(input, "source");
+  return {
+    system: nonempty(label(r.field("system"), r.at("system"), 32), r.at("system")),
+    ...r.has("topic") ? { topic: label(r.field("topic"), r.at("topic"), 256) } : {},
+    ...r.has("event_id") ? { event_id: label(r.field("event_id"), r.at("event_id"), 64) } : {}
+  };
+}
+function readUrl(input) {
+  if (typeof input !== "string") fail2("url", "wrong_type");
+  if (utf8Length2(input) > 2048) fail2("url", "too_long");
+  try {
+    if (new URL(input).protocol !== "https:") fail2("url", "invalid_value");
+  } catch {
+    fail2("url", "invalid_value");
+  }
+  return input;
+}
+function formatChannelEventLine(content) {
+  const { summary, subject } = content;
+  const head = subject?.ticket ? `${subject.ticket} ${summary}` : summary;
+  const tail = subject?.branch ?? (subject?.pr !== void 0 ? `PR #${subject.pr}` : void 0);
+  return tail ? `${head} \xB7 ${tail}` : head;
+}
+function encodeChannelEvent(input) {
+  return safely(() => {
+    const checked = decodeWith2(() => {
+      record(input, "");
+      return { ...input, v: 1, body: "" };
+    });
+    if (!checked.ok) return checked;
+    const decoded = decodeChannelEvent(checked.value);
+    if (!decoded.ok) return decoded;
+    return decodeChannelEvent({ ...decoded.value, body: formatChannelEventLine(decoded.value) });
+  });
+}
+function statusFor(content) {
+  if (content.status !== void 0) return content.status;
+  switch (content.kind) {
+    case "ci.passed":
+    case "pr.merged":
+    case "agent.unblocked":
+      return "success";
+    case "ci.failed":
+      return "failure";
+    case "pr.ready_for_review":
+    case "pr.parked_ready":
+      return "pending";
+    case "agent.paused":
+    case "agent.blocked":
+    case "agent.pause.request":
+      return "attention";
+    default:
+      return content.kind.startsWith("agent.attention.") && !content.kind.endsWith(".resolved") ? "attention" : "info";
+  }
+}
+
+export {
+  LISTENING_MODES,
+  decodeListeningMode,
+  fail2 as fail,
+  decodeWith2 as decodeWith,
+  object2 as object,
+  array,
+  elementPath,
+  utf8Length2 as utf8Length,
+  isWellFormed2 as isWellFormed,
+  text,
+  label,
+  displayText,
+  identifier2 as identifier,
+  nullable2 as nullable,
+  literal2 as literal,
+  version2 as version,
+  safeInteger2 as safeInteger,
+  utcTimestamp2 as utcTimestamp,
+  reserved,
+  validateAgentName,
+  M1_LABEL_MAX_BYTES,
+  agentConfirmPagePath,
+  readHarness,
+  readHttpUrl,
+  readMatrixUserId,
+  readRoomId,
+  LISTENING_MODE_COMMAND_TYPE,
+  LISTENING_MODE_MEMBER_KEY,
+  DEFAULT_LISTENING_MODE,
+  decodeListeningModeCommand,
+  memberListeningMode,
+  CHANNEL_EVENT_TYPE,
+  decodeChannelEvent,
+  formatChannelEventLine,
+  encodeChannelEvent,
+  statusFor
+};

package/dist/chunk-H2JCKPFR.mjs

@@ -0,0 +1,149 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  StateError,
+  filesForDir,
+  readJson,
+  writeJsonAtomic
+} from "./chunk-S6XASSNU.mjs";
+import {
+  DEFAULT_LISTENING_MODE,
+  decodeChannelEvent,
+  decodeListeningMode,
+  formatChannelEventLine
+} from "./chunk-GO5DD2TR.mjs";
+
+// src/inbox.ts
+import * as fs from "node:fs/promises";
+async function readEntries(files) {
+  let content;
+  try {
+    content = await fs.readFile(files.inbox, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw new StateError("storage_failed");
+  }
+  const entries = [];
+  for (const line of content.split("\n").slice(0, -1)) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry && ["eventId", "roomId", "ts", "sender", "senderLabel", "body"].every((key) => typeof entry[key] === "string") && ["human", "agent", "unknown"].includes(entry.senderKind) && ["message", "event"].includes(entry.kind)) entries.push(entry);
+    } catch {
+    }
+  }
+  return entries;
+}
+async function appendEntries(files, entries) {
+  const seen = new Set((await readEntries(files)).map((entry) => entry.eventId));
+  const fresh = entries.filter((entry) => {
+    if (seen.has(entry.eventId)) return false;
+    seen.add(entry.eventId);
+    return true;
+  });
+  if (fresh.length) {
+    try {
+      await fs.appendFile(files.inbox, fresh.map((entry) => JSON.stringify(entry) + "\n").join(""), { mode: 384, flag: "a" });
+    } catch {
+      throw new StateError("storage_failed");
+    }
+  }
+  return fresh;
+}
+async function readCursor(files) {
+  const cursor = await readJson(files.cursor);
+  return cursor && (cursor.lastDeliveredEventId === null || typeof cursor.lastDeliveredEventId === "string") && Number.isSafeInteger(cursor.deliveredCount) && cursor.deliveredCount >= 0 ? cursor : { lastDeliveredEventId: null, deliveredCount: 0 };
+}
+async function unread(files) {
+  const cursor = await readCursor(files);
+  const entries = await readEntries(files);
+  return { entries: entries.slice(cursor.deliveredCount), cursor };
+}
+async function unreadCounts(files) {
+  const { entries } = await unread(files);
+  return { total: entries.length, messages: entries.filter((entry) => entry.kind === "message").length };
+}
+async function advanceCursor(files, expected, delivered) {
+  const current = await readCursor(files);
+  if (current.deliveredCount !== expected.deliveredCount || current.lastDeliveredEventId !== expected.lastDeliveredEventId) return "conflict";
+  if (!delivered.length) return expected;
+  const entries = await readEntries(files);
+  const slice = entries.slice(expected.deliveredCount, expected.deliveredCount + delivered.length);
+  if (slice.length !== delivered.length || slice.some((entry, index) => entry.eventId !== delivered[index]?.eventId)) return "conflict";
+  const next = { lastDeliveredEventId: delivered[delivered.length - 1].eventId, deliveredCount: expected.deliveredCount + delivered.length };
+  await writeJsonAtomic(files.cursor, next);
+  return next;
+}
+async function appendInbox(dir, entry) {
+  return (await appendEntries(filesForDir(dir), [entry])).length === 1;
+}
+function unreadCount(dir) {
+  return unreadCounts(filesForDir(dir));
+}
+
+// src/activity.ts
+import path from "node:path";
+async function readActivity(files) {
+  const activity = await readJson(path.join(files.dir, "activity.json"));
+  return activity && ["idle", "busy"].includes(activity.state) && typeof activity.updatedAt === "string" && Number.isFinite(Date.parse(activity.updatedAt)) ? activity : { state: "busy", updatedAt: (/* @__PURE__ */ new Date(0)).toISOString() };
+}
+async function writeActivity(files, state, now = () => /* @__PURE__ */ new Date()) {
+  const activity = { state, updatedAt: now().toISOString() };
+  await writeJsonAtomic(path.join(files.dir, "activity.json"), activity);
+  return activity;
+}
+
+// src/mode.ts
+async function readListeningMode(files) {
+  const content = await readJson(files.mode);
+  const decoded = decodeListeningMode(typeof content === "object" && content !== null ? content.mode : void 0);
+  return decoded.ok ? decoded.value : DEFAULT_LISTENING_MODE;
+}
+async function applyListeningMode(files, next, meta, now = () => /* @__PURE__ */ new Date()) {
+  const previous = await readListeningMode(files);
+  if (previous === "async" && next !== "async") {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const { cursor, entries } = await unread(files);
+      if (await advanceCursor(files, cursor, entries) !== "conflict") break;
+      if (attempt === 1) throw new StateError("storage_failed");
+    }
+  }
+  await writeJsonAtomic(files.mode, { mode: next, ...meta, updatedAt: now().toISOString() });
+  return { previous, next };
+}
+
+// src/events/receive.ts
+function toEventInboxEntry(base, rawContent) {
+  const decoded = decodeChannelEvent(rawContent);
+  if (!decoded.ok) return null;
+  const content = decoded.value;
+  return {
+    entry: { ...base, kind: "event", body: formatChannelEventLine(content) + (content.url ? " " + content.url : "") },
+    ...content.key !== void 0 ? { key: content.key } : {}
+  };
+}
+function createEventKeyFilter() {
+  const seen = /* @__PURE__ */ new Set();
+  return (key) => {
+    if (key === void 0) return true;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  };
+}
+function isWakeEntry(entry) {
+  return entry.kind === "message";
+}
+
+export {
+  readCursor,
+  unread,
+  advanceCursor,
+  appendInbox,
+  unreadCount,
+  readActivity,
+  writeActivity,
+  readListeningMode,
+  applyListeningMode,
+  toEventInboxEntry,
+  createEventKeyFilter,
+  isWakeEntry
+};

package/dist/chunk-HMGN52QY.mjs

@@ -0,0 +1,11 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  define_KHALA_BUNDLE_default
+} from "./chunk-6FNXMYOM.mjs";
+
+// src/bundle.ts
+var bundle = typeof define_KHALA_BUNDLE_default === "undefined" ? void 0 : define_KHALA_BUNDLE_default;
+
+export {
+  bundle
+};