conversationalist 0.0.9 → 0.0.11

package/dist/markdown/index.js

@@ -2630,16 +2630,16 @@ var require_dumper = __commonJS((exports, module) => {
     this.usedDuplicates = null;
   }
   function indentString(string, spaces) {
-    var ind = common.repeat(" ", spaces), position = 0, next = -1, result = "", line, length = string.length;
+    var ind = common.repeat(" ", spaces), position = 0, next2 = -1, result = "", line, length = string.length;
     while (position < length) {
-      next = string.indexOf(`
+      next2 = string.indexOf(`
 `, position);
-      if (next === -1) {
+      if (next2 === -1) {
         line = string.slice(position);
         position = length;
       } else {
-        line = string.slice(position, next + 1);
-        position = next + 1;
+        line = string.slice(position, next2 + 1);
+        position = next2 + 1;
       }
       if (line.length && line !== `
 `)
@@ -2800,17 +2800,17 @@ var require_dumper = __commonJS((exports, module) => {
       return line;
     var breakRe = / [^ ]/g;
     var match;
-    var start = 0, end, curr = 0, next = 0;
+    var start = 0, end, curr = 0, next2 = 0;
     var result = "";
     while (match = breakRe.exec(line)) {
-      next = match.index;
-      if (next - start > width) {
-        end = curr > start ? curr : next;
+      next2 = match.index;
+      if (next2 - start > width) {
+        end = curr > start ? curr : next2;
         result += `
 ` + line.slice(start, end);
         start = end + 1;
       }
-      curr = next;
+      curr = next2;
     }
     result += `
 `;
@@ -3491,6 +3491,1773 @@ var require_gray_matter = __commonJS((exports, module) => {
   module.exports = matter;
 });
 
+// node_modules/event-emission/dist/index.js
+var SymbolObservable = typeof Symbol === "function" && Symbol.observable || Symbol.for("@@observable");
+if (typeof Symbol === "function") {
+  Symbol.observable = SymbolObservable;
+}
+function getMethod(obj, key) {
+  if (obj === null || obj === undefined)
+    return;
+  const value = obj[key];
+  if (value == null)
+    return;
+  if (typeof value !== "function") {
+    throw new TypeError(value + " is not a function");
+  }
+  return value;
+}
+function hostReportError(e) {
+  if (typeof queueMicrotask === "function") {
+    queueMicrotask(() => {
+      throw e;
+    });
+  } else {
+    setTimeout(() => {
+      throw e;
+    });
+  }
+}
+function SubscriptionObserverImpl(subscription) {
+  this._subscription = subscription;
+}
+SubscriptionObserverImpl.prototype = Object.create(Object.prototype);
+Object.defineProperties(SubscriptionObserverImpl.prototype, {
+  constructor: { value: Object, configurable: true, writable: true },
+  closed: {
+    get() {
+      return this._subscription._closed;
+    },
+    configurable: true
+  },
+  next: {
+    value: function next(value) {
+      const subscription = this._subscription;
+      if (subscription._closed)
+        return;
+      const observer = subscription._observer;
+      try {
+        const m = getMethod(observer, "next");
+        if (!m)
+          return;
+        return m.call(observer, value);
+      } catch (e) {
+        try {
+          this.error(e);
+        } catch (err) {
+          hostReportError(err);
+        }
+      }
+    },
+    configurable: true,
+    writable: true
+  },
+  error: {
+    value: function error(errorValue) {
+      const subscription = this._subscription;
+      if (subscription._closed)
+        throw errorValue;
+      subscription._closed = true;
+      const observer = subscription._observer;
+      try {
+        const m = getMethod(observer, "error");
+        if (m) {
+          return m.call(observer, errorValue);
+        }
+        throw errorValue;
+      } finally {
+        subscription._cleanup();
+      }
+    },
+    configurable: true,
+    writable: true
+  },
+  complete: {
+    value: function complete(value) {
+      const subscription = this._subscription;
+      if (subscription._closed)
+        return;
+      subscription._closed = true;
+      const observer = subscription._observer;
+      try {
+        const m = getMethod(observer, "complete");
+        if (m) {
+          return m.call(observer, value);
+        }
+        return;
+      } finally {
+        subscription._cleanup();
+      }
+    },
+    configurable: true,
+    writable: true
+  }
+});
+Object.defineProperty(SubscriptionObserverImpl.prototype.next, "length", { value: 1 });
+Object.defineProperty(SubscriptionObserverImpl.prototype.error, "length", { value: 1 });
+Object.defineProperty(SubscriptionObserverImpl.prototype.complete, "length", {
+  value: 1
+});
+function Subscription(observer, subscriber) {
+  this._observer = observer;
+  this._cleanupFn = undefined;
+  this._closed = false;
+  const subscriptionObserver = new SubscriptionObserverImpl(this);
+  try {
+    const start = getMethod(observer, "start");
+    if (start) {
+      start.call(observer, this);
+    }
+  } catch (e) {
+    hostReportError(e);
+  }
+  if (this._closed)
+    return;
+  try {
+    const cleanup = subscriber(subscriptionObserver);
+    if (cleanup != null) {
+      if (typeof cleanup !== "function" && typeof cleanup.unsubscribe !== "function") {
+        throw new TypeError(cleanup + " is not a function or a subscription");
+      }
+      this._cleanupFn = cleanup;
+      if (this._closed) {
+        this._cleanup();
+      }
+    }
+  } catch (e) {
+    subscriptionObserver.error(e);
+  }
+}
+Subscription.prototype = Object.create(Object.prototype);
+Object.defineProperties(Subscription.prototype, {
+  constructor: { value: Object, configurable: true, writable: true },
+  closed: {
+    get() {
+      return this._closed;
+    },
+    configurable: true
+  },
+  unsubscribe: {
+    value: function unsubscribe() {
+      if (this._closed)
+        return;
+      this._closed = true;
+      this._cleanup();
+    },
+    configurable: true,
+    writable: true
+  },
+  _cleanup: {
+    value: function _cleanup() {
+      const cleanup = this._cleanupFn;
+      if (!cleanup)
+        return;
+      this._cleanupFn = undefined;
+      try {
+        if (typeof cleanup === "function") {
+          cleanup();
+        } else if (cleanup && typeof cleanup.unsubscribe === "function") {
+          cleanup.unsubscribe();
+        }
+      } catch (e) {
+        hostReportError(e);
+      }
+    },
+    configurable: true,
+    writable: true
+  }
+});
+
+class Observable {
+  _subscriber;
+  constructor(subscriber) {
+    if (typeof subscriber !== "function") {
+      throw new TypeError("Observable initializer must be a function");
+    }
+    this._subscriber = subscriber;
+  }
+  subscribe(observerOrNext, error2, complete2) {
+    let observer;
+    if (typeof observerOrNext === "function") {
+      observer = {
+        next: observerOrNext,
+        error: error2,
+        complete: complete2
+      };
+    } else if (typeof observerOrNext !== "object" || observerOrNext === null) {
+      throw new TypeError(observerOrNext + " is not an object");
+    } else {
+      observer = observerOrNext;
+    }
+    return new Subscription(observer, this._subscriber);
+  }
+  [SymbolObservable]() {
+    return this;
+  }
+  static of(...items) {
+    const C = typeof this === "function" ? this : Observable;
+    return new C((observer) => {
+      for (let i = 0;i < items.length; ++i) {
+        observer.next(items[i]);
+        if (observer.closed)
+          return;
+      }
+      observer.complete();
+    });
+  }
+  static from(x) {
+    const C = typeof this === "function" ? this : Observable;
+    if (x == null)
+      throw new TypeError(x + " is not an object");
+    const method = x[SymbolObservable];
+    if (method != null) {
+      if (typeof method !== "function") {
+        throw new TypeError(method + " is not a function");
+      }
+      const observable = method.call(x);
+      if (Object(observable) !== observable) {
+        throw new TypeError(observable + " is not an object");
+      }
+      if (observable.constructor === C) {
+        return observable;
+      }
+      return new C((observer) => observable.subscribe(observer));
+    }
+    if (Symbol.iterator in x) {
+      return new C((observer) => {
+        for (const item of x) {
+          observer.next(item);
+          if (observer.closed)
+            return;
+        }
+        observer.complete();
+      });
+    }
+    throw new TypeError(x + " is not observable");
+  }
+}
+var PROXY_MARKER = Symbol.for("@lasercat/event-emission/proxy");
+var ORIGINAL_TARGET = Symbol.for("@lasercat/event-emission/original");
+var ARRAY_MUTATORS = new Set([
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "fill",
+  "copyWithin"
+]);
+function isProxyable(value) {
+  return value !== null && typeof value === "object" && !isProxied(value) && !(value instanceof Date) && !(value instanceof RegExp) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof WeakMap) && !(value instanceof WeakSet) && !(value instanceof Promise) && !(value instanceof Error) && !(value instanceof ArrayBuffer) && !ArrayBuffer.isView(value);
+}
+function isProxied(value) {
+  return typeof value === "object" && value !== null && value[PROXY_MARKER] === true;
+}
+function isArrayMutator(prop) {
+  return typeof prop === "string" && ARRAY_MUTATORS.has(prop);
+}
+function cloneAlongPath(obj, path) {
+  const isArray = Array.isArray(obj);
+  const rootClone = isArray ? [...obj] : { ...obj };
+  if (!path || isArray) {
+    return rootClone;
+  }
+  const parts = path.split(".");
+  const result = rootClone;
+  let current = result;
+  for (let i = 0;i < parts.length; i++) {
+    const key = parts[i];
+    const value = current[key];
+    if (value !== null && typeof value === "object") {
+      current[key] = Array.isArray(value) ? [...value] : { ...value };
+      if (i < parts.length - 1) {
+        current = current[key];
+      }
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+function cloneForComparison(obj, strategy, changedPath, deepClone) {
+  if (obj === null || typeof obj !== "object")
+    return obj;
+  switch (strategy) {
+    case "shallow":
+      return Array.isArray(obj) ? [...obj] : { ...obj };
+    case "deep":
+      if (deepClone) {
+        return deepClone(obj);
+      }
+      if (typeof structuredClone !== "function") {
+        throw new Error("structuredClone is not available in this runtime; provide observe.deepClone, or use cloneStrategy 'path' or 'shallow'.");
+      }
+      return structuredClone(obj);
+    case "path":
+      return cloneAlongPath(obj, changedPath);
+    default:
+      return obj;
+  }
+}
+function computeArrayDiff(method, before, _after, args) {
+  switch (method) {
+    case "push":
+      return { added: args };
+    case "pop":
+      return { removed: before.length > 0 ? [before[before.length - 1]] : [] };
+    case "shift":
+      return { removed: before.length > 0 ? [before[0]] : [] };
+    case "unshift":
+      return { added: args };
+    case "splice": {
+      const [start, deleteCount, ...items] = args;
+      const actualStart = start < 0 ? Math.max(before.length + start, 0) : Math.min(start, before.length);
+      const actualDeleteCount = Math.min(deleteCount ?? before.length - actualStart, before.length - actualStart);
+      return {
+        removed: before.slice(actualStart, actualStart + actualDeleteCount),
+        added: items
+      };
+    }
+    case "sort":
+    case "reverse":
+    case "fill":
+    case "copyWithin":
+      return {};
+    default:
+      return {};
+  }
+}
+var proxyRegistry = new WeakMap;
+function getContextRegistry(target) {
+  let contextMap = proxyRegistry.get(target);
+  if (!contextMap) {
+    contextMap = new WeakMap;
+    proxyRegistry.set(target, contextMap);
+  }
+  return contextMap;
+}
+function createArrayMethodInterceptor(array, method, path, context) {
+  const original = array[method];
+  return function(...args) {
+    const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, path, context.options.deepClone);
+    const previousItems = [...array];
+    const result = original.apply(this, args);
+    const { added, removed } = computeArrayDiff(method, previousItems, array, args);
+    const methodEventPath = path ? `update:${path}.${method}` : `update:${method}`;
+    const arrayEventPath = path ? `update:${path}` : "update:";
+    context.eventTarget.dispatchEvent({
+      type: methodEventPath,
+      detail: {
+        method,
+        args,
+        result,
+        added,
+        removed,
+        current: context.originalRoot,
+        previous: previousState
+      }
+    });
+    if (path) {
+      context.eventTarget.dispatchEvent({
+        type: arrayEventPath,
+        detail: {
+          value: array,
+          current: context.originalRoot,
+          previous: previousState
+        }
+      });
+    }
+    context.eventTarget.dispatchEvent({
+      type: "update",
+      detail: {
+        current: context.originalRoot,
+        previous: previousState
+      }
+    });
+    return result;
+  };
+}
+function createObservableProxyInternal(target, path, context) {
+  const contextRegistry = getContextRegistry(target);
+  const existing = contextRegistry.get(context);
+  if (existing) {
+    return existing.proxy;
+  }
+  const proxy = new Proxy(target, {
+    get(obj, prop, receiver) {
+      if (prop === PROXY_MARKER)
+        return true;
+      if (prop === ORIGINAL_TARGET)
+        return obj;
+      if (typeof prop === "symbol") {
+        return Reflect.get(obj, prop, receiver);
+      }
+      const value = Reflect.get(obj, prop, receiver);
+      if (Array.isArray(obj) && isArrayMutator(prop)) {
+        return createArrayMethodInterceptor(obj, prop, path, context);
+      }
+      if (context.options.deep && isProxyable(value)) {
+        const nestedPath = path ? `${path}.${prop}` : prop;
+        return createObservableProxyInternal(value, nestedPath, context);
+      }
+      return value;
+    },
+    set(obj, prop, value, receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.set(obj, prop, value, receiver);
+      }
+      const oldValue = Reflect.get(obj, prop, receiver);
+      if (Object.is(oldValue, value)) {
+        return true;
+      }
+      const propPath = path ? `${path}.${prop}` : prop;
+      const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, propPath, context.options.deepClone);
+      const success = Reflect.set(obj, prop, value, receiver);
+      if (success) {
+        context.eventTarget.dispatchEvent({
+          type: `update:${propPath}`,
+          detail: {
+            value,
+            current: context.originalRoot,
+            previous: previousState
+          }
+        });
+        context.eventTarget.dispatchEvent({
+          type: "update",
+          detail: {
+            current: context.originalRoot,
+            previous: previousState
+          }
+        });
+      }
+      return success;
+    },
+    deleteProperty(obj, prop) {
+      if (typeof prop === "symbol") {
+        return Reflect.deleteProperty(obj, prop);
+      }
+      const propPath = path ? `${path}.${String(prop)}` : String(prop);
+      const previousState = cloneForComparison(context.originalRoot, context.options.cloneStrategy, propPath, context.options.deepClone);
+      const success = Reflect.deleteProperty(obj, prop);
+      if (success) {
+        context.eventTarget.dispatchEvent({
+          type: `update:${propPath}`,
+          detail: {
+            value: undefined,
+            current: context.originalRoot,
+            previous: previousState
+          }
+        });
+        context.eventTarget.dispatchEvent({
+          type: "update",
+          detail: {
+            current: context.originalRoot,
+            previous: previousState
+          }
+        });
+      }
+      return success;
+    }
+  });
+  contextRegistry.set(context, {
+    proxy,
+    path
+  });
+  return proxy;
+}
+function isEventTarget(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.addEventListener === "function" && typeof obj.removeEventListener === "function" && typeof obj.dispatchEvent === "function";
+}
+function setupEventForwarding(source, target) {
+  const handlers = new Map;
+  const sourceAddEventListener = source.addEventListener.bind(source);
+  const sourceRemoveEventListener = source.removeEventListener.bind(source);
+  const forwardHandler = (type) => (event) => {
+    const detail = event.detail ?? event;
+    target.dispatchEvent({
+      type,
+      detail
+    });
+  };
+  const originalAddEventListener = target.addEventListener.bind(target);
+  const wrappedAddEventListener = (type, listener, options2) => {
+    if (!handlers.has(type) && type !== "update" && !type.startsWith("update:")) {
+      const handler = forwardHandler(type);
+      handlers.set(type, handler);
+      sourceAddEventListener(type, handler);
+    }
+    return originalAddEventListener(type, listener, options2);
+  };
+  target.addEventListener = wrappedAddEventListener;
+  return () => {
+    target.addEventListener = originalAddEventListener;
+    for (const [type, handler] of handlers) {
+      sourceRemoveEventListener(type, handler);
+    }
+    handlers.clear();
+  };
+}
+function createObservableProxy(target, eventTarget, options2) {
+  const resolvedOptions = {
+    deep: options2?.deep ?? true,
+    cloneStrategy: options2?.cloneStrategy ?? "path",
+    deepClone: options2?.deepClone
+  };
+  const context = {
+    eventTarget,
+    originalRoot: target,
+    options: resolvedOptions
+  };
+  const proxy = createObservableProxyInternal(target, "", context);
+  if (isEventTarget(target)) {
+    const cleanupForwarding = setupEventForwarding(target, eventTarget);
+    const maybeComplete = eventTarget.complete;
+    if (typeof maybeComplete === "function") {
+      const originalComplete = maybeComplete.bind(eventTarget);
+      let cleaned = false;
+      eventTarget.complete = () => {
+        if (!cleaned) {
+          cleaned = true;
+          cleanupForwarding();
+        }
+        return originalComplete();
+      };
+    }
+  }
+  return proxy;
+}
+
+class BufferOverflowError extends Error {
+  constructor(eventType, bufferSize) {
+    super(`Buffer overflow for event type "${eventType}" (max: ${bufferSize})`);
+    this.name = "BufferOverflowError";
+  }
+}
+function matchesWildcard(eventType, pattern) {
+  if (pattern === "*")
+    return true;
+  return pattern.endsWith(":*") && eventType.startsWith(pattern.slice(0, -2) + ":");
+}
+var EVENT_STATE = Symbol("event-emission:event-state");
+function createEventTarget(targetOrOpts, opts) {
+  if (opts?.observe === true && targetOrOpts && typeof targetOrOpts === "object") {
+    const target = targetOrOpts;
+    const eventTarget = createEventTargetInternal({
+      onListenerError: opts.onListenerError
+    });
+    const proxy = createObservableProxy(target, eventTarget, {
+      deep: opts.deep,
+      cloneStrategy: opts.cloneStrategy,
+      deepClone: opts.deepClone
+    });
+    const methodNames = [
+      "addEventListener",
+      "removeEventListener",
+      "dispatchEvent",
+      "clear",
+      "on",
+      "once",
+      "removeAllListeners",
+      "pipe",
+      "addWildcardListener",
+      "removeWildcardListener",
+      "complete",
+      "subscribe",
+      "toObservable",
+      "events"
+    ];
+    for (const name of methodNames) {
+      Object.defineProperty(proxy, name, {
+        value: eventTarget[name],
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    Object.defineProperty(proxy, "completed", {
+      get: () => eventTarget.completed,
+      enumerable: false,
+      configurable: true
+    });
+    return proxy;
+  }
+  return createEventTargetInternal(targetOrOpts);
+}
+function createEventTargetInternal(opts) {
+  const listeners = new Map;
+  const wildcardListeners = new Set;
+  let isCompleted = false;
+  const completionCallbacks = new Set;
+  const now = () => typeof globalThis.performance?.now === "function" ? globalThis.performance.now() : Date.now();
+  const initializeEventState = (state, type, bubbles, cancelable) => {
+    state.initializedFlag = true;
+    state.stopPropagationFlag = false;
+    state.stopImmediatePropagationFlag = false;
+    state.canceledFlag = false;
+    state.isTrusted = false;
+    state.target = null;
+    state.currentTarget = null;
+    state.eventPhase = 0;
+    state.type = type;
+    state.bubbles = bubbles;
+    state.cancelable = cancelable;
+  };
+  const setCanceledFlag = (state) => {
+    if (state.cancelable && !state.inPassiveListenerFlag) {
+      state.canceledFlag = true;
+    }
+  };
+  const createEvent = (type, detail, init) => {
+    const state = {
+      dispatchFlag: false,
+      initializedFlag: true,
+      stopPropagationFlag: false,
+      stopImmediatePropagationFlag: false,
+      canceledFlag: false,
+      inPassiveListenerFlag: false,
+      composedFlag: Boolean(init?.composed),
+      eventPhase: init?.eventPhase ?? 0,
+      currentTarget: init?.currentTarget ?? init?.target ?? null,
+      target: init?.target ?? null,
+      timeStamp: init?.timeStamp ?? now(),
+      path: [],
+      type,
+      bubbles: Boolean(init?.bubbles),
+      cancelable: Boolean(init?.cancelable),
+      isTrusted: false
+    };
+    const event = { detail };
+    Object.defineProperties(event, {
+      type: {
+        get: () => state.type,
+        enumerable: true,
+        configurable: true
+      },
+      bubbles: {
+        get: () => state.bubbles,
+        enumerable: true,
+        configurable: true
+      },
+      cancelable: {
+        get: () => state.cancelable,
+        enumerable: true,
+        configurable: true
+      },
+      cancelBubble: {
+        get: () => state.stopPropagationFlag,
+        set: (value) => {
+          if (value)
+            state.stopPropagationFlag = true;
+        },
+        enumerable: true,
+        configurable: true
+      },
+      composed: {
+        get: () => state.composedFlag,
+        enumerable: true,
+        configurable: true
+      },
+      currentTarget: {
+        get: () => state.currentTarget,
+        enumerable: true,
+        configurable: true
+      },
+      defaultPrevented: {
+        get: () => state.canceledFlag,
+        enumerable: true,
+        configurable: true
+      },
+      eventPhase: {
+        get: () => state.eventPhase,
+        enumerable: true,
+        configurable: true
+      },
+      isTrusted: {
+        get: () => state.isTrusted,
+        enumerable: true,
+        configurable: true
+      },
+      returnValue: {
+        get: () => !state.canceledFlag,
+        set: (value) => {
+          if (value === false)
+            setCanceledFlag(state);
+        },
+        enumerable: true,
+        configurable: true
+      },
+      srcElement: {
+        get: () => state.target,
+        enumerable: true,
+        configurable: true
+      },
+      target: {
+        get: () => state.target,
+        enumerable: true,
+        configurable: true
+      },
+      timeStamp: {
+        get: () => state.timeStamp,
+        enumerable: true,
+        configurable: true
+      },
+      composedPath: {
+        value: () => state.path.map((entry) => entry.invocationTarget),
+        enumerable: true,
+        configurable: true
+      },
+      initEvent: {
+        value: (newType, bubbles = false, cancelable = false) => {
+          if (state.dispatchFlag)
+            return;
+          initializeEventState(state, newType, Boolean(bubbles), Boolean(cancelable));
+        },
+        enumerable: true,
+        configurable: true
+      },
+      preventDefault: {
+        value: () => setCanceledFlag(state),
+        enumerable: true,
+        configurable: true
+      },
+      stopImmediatePropagation: {
+        value: () => {
+          state.stopPropagationFlag = true;
+          state.stopImmediatePropagationFlag = true;
+        },
+        enumerable: true,
+        configurable: true
+      },
+      stopPropagation: {
+        value: () => {
+          state.stopPropagationFlag = true;
+        },
+        enumerable: true,
+        configurable: true
+      },
+      NONE: { value: 0, enumerable: true, configurable: true },
+      CAPTURING_PHASE: { value: 1, enumerable: true, configurable: true },
+      AT_TARGET: { value: 2, enumerable: true, configurable: true },
+      BUBBLING_PHASE: { value: 3, enumerable: true, configurable: true },
+      [EVENT_STATE]: {
+        value: state,
+        enumerable: false,
+        configurable: false
+      }
+    });
+    return event;
+  };
+  const getEventState = (event) => event[EVENT_STATE];
+  const normalizeAddListenerOptions = (options2) => {
+    if (typeof options2 === "boolean") {
+      return {
+        capture: options2,
+        passive: false,
+        once: false,
+        signal: null
+      };
+    }
+    return {
+      capture: Boolean(options2?.capture),
+      passive: Boolean(options2?.passive),
+      once: Boolean(options2?.once),
+      signal: options2?.signal ?? null
+    };
+  };
+  const normalizeCaptureOption = (options2) => {
+    if (typeof options2 === "boolean")
+      return options2;
+    return Boolean(options2?.capture);
+  };
+  const removeListenerRecord = (type, record) => {
+    if (record.removed)
+      return;
+    record.removed = true;
+    const list = listeners.get(type);
+    if (list) {
+      const idx = list.indexOf(record);
+      if (idx >= 0)
+        list.splice(idx, 1);
+      if (list.length === 0)
+        listeners.delete(type);
+    }
+    if (record.signal && record.abortHandler) {
+      record.signal.removeEventListener("abort", record.abortHandler);
+    }
+  };
+  const handleListenerError = (eventType, error2) => {
+    if (eventType === "error")
+      return;
+    if (opts?.onListenerError) {
+      opts.onListenerError(eventType, error2);
+      return;
+    }
+    const errorListeners = listeners.get("error");
+    if (errorListeners && errorListeners.length > 0) {
+      dispatchEvent({ type: "error", detail: error2 });
+    } else {
+      throw error2;
+    }
+  };
+  const notifyWildcardListeners = (eventType, event) => {
+    if (wildcardListeners.size === 0)
+      return;
+    for (const rec of Array.from(wildcardListeners)) {
+      if (!matchesWildcard(eventType, rec.pattern))
+        continue;
+      const baseEvent = createEvent(rec.pattern, event.detail, {
+        target,
+        currentTarget: target,
+        eventPhase: 2,
+        bubbles: event.bubbles,
+        cancelable: event.cancelable,
+        composed: event.composed
+      });
+      const wildcardEvent = Object.defineProperties(baseEvent, {
+        originalType: { value: eventType, enumerable: true, configurable: true }
+      });
+      try {
+        const fn = rec.fn;
+        const res = fn(wildcardEvent);
+        if (res && typeof res.then === "function") {
+          res.catch((error2) => {
+            try {
+              handleListenerError(eventType, error2);
+            } catch (rethrown) {
+              queueMicrotask(() => {
+                throw rethrown;
+              });
+            }
+          });
+        }
+      } catch (error2) {
+        handleListenerError(eventType, error2);
+      } finally {
+        if (rec.once)
+          wildcardListeners.delete(rec);
+      }
+      const state = getEventState(wildcardEvent);
+      if (state?.stopImmediatePropagationFlag || state?.stopPropagationFlag) {
+        break;
+      }
+    }
+  };
+  const addEventListener = (type, listener, options2) => {
+    if (isCompleted || !listener) {
+      return () => {};
+    }
+    const { capture, passive, once, signal } = normalizeAddListenerOptions(options2);
+    let list = listeners.get(type);
+    if (!list) {
+      list = [];
+      listeners.set(type, list);
+    }
+    for (const existing of list) {
+      if (existing.original === listener && existing.capture === capture) {
+        return () => removeEventListener(type, listener, options2);
+      }
+    }
+    const original = listener;
+    const callback = typeof listener === "function" ? listener : (event) => listener.handleEvent(event);
+    const record = {
+      type,
+      original,
+      callback,
+      capture,
+      passive,
+      once,
+      signal,
+      removed: false
+    };
+    list.push(record);
+    const unsubscribe2 = () => removeListenerRecord(type, record);
+    if (signal) {
+      const onAbort = () => removeListenerRecord(type, record);
+      record.abortHandler = onAbort;
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted)
+        onAbort();
+    }
+    return unsubscribe2;
+  };
+  const addWildcardListener = (pattern, listener, options2) => {
+    if (isCompleted)
+      return () => {};
+    const opts2 = options2 ?? {};
+    for (const existing of wildcardListeners) {
+      if (existing.pattern === pattern && existing.fn === listener) {
+        return () => removeWildcardListener(pattern, listener);
+      }
+    }
+    const record = {
+      fn: listener,
+      pattern,
+      once: opts2.once,
+      signal: opts2.signal
+    };
+    wildcardListeners.add(record);
+    const unsubscribe2 = () => {
+      wildcardListeners.delete(record);
+      if (record.signal && record.abortHandler) {
+        record.signal.removeEventListener("abort", record.abortHandler);
+      }
+    };
+    if (opts2.signal) {
+      const onAbort = () => unsubscribe2();
+      record.abortHandler = onAbort;
+      opts2.signal.addEventListener("abort", onAbort, { once: true });
+      if (opts2.signal.aborted)
+        onAbort();
+    }
+    return unsubscribe2;
+  };
+  const removeWildcardListener = (pattern, listener) => {
+    for (const record of Array.from(wildcardListeners)) {
+      if (record.pattern === pattern && record.fn === listener) {
+        wildcardListeners.delete(record);
+        if (record.signal && record.abortHandler) {
+          record.signal.removeEventListener("abort", record.abortHandler);
+        }
+      }
+    }
+  };
+  const invokeListeners = (eventType, event, phase, listenersSnapshot) => {
+    const state = getEventState(event);
+    if (!state || state.stopPropagationFlag)
+      return;
+    state.currentTarget = target;
+    state.target = target;
+    state.eventPhase = event.AT_TARGET;
+    for (const rec of listenersSnapshot) {
+      if (rec.removed)
+        continue;
+      if (phase === "capturing" && !rec.capture)
+        continue;
+      if (phase === "bubbling" && rec.capture)
+        continue;
+      if (rec.once)
+        removeListenerRecord(rec.type, rec);
+      if (rec.passive)
+        state.inPassiveListenerFlag = true;
+      try {
+        const res = rec.callback.call(state.currentTarget, event);
+        if (res && typeof res.then === "function") {
+          res.catch((error2) => {
+            try {
+              handleListenerError(eventType, error2);
+            } catch (rethrown) {
+              queueMicrotask(() => {
+                throw rethrown;
+              });
+            }
+          });
+        }
+      } catch (error2) {
+        handleListenerError(eventType, error2);
+      } finally {
+        if (rec.passive)
+          state.inPassiveListenerFlag = false;
+      }
+      if (state.stopImmediatePropagationFlag)
+        break;
+    }
+  };
+  const dispatchEvent = (eventInput) => {
+    if (isCompleted)
+      return false;
+    let event;
+    let state;
+    if (eventInput && typeof eventInput === "object") {
+      state = getEventState(eventInput);
+      if (state) {
+        event = eventInput;
+      } else {
+        const input = eventInput;
+        if (typeof input.type !== "string") {
+          throw new TypeError("Event type must be a string");
+        }
+        event = createEvent(input.type, input.detail, {
+          bubbles: input.bubbles,
+          cancelable: input.cancelable,
+          composed: input.composed,
+          timeStamp: input.timeStamp
+        });
+        state = getEventState(event);
+      }
+    } else {
+      throw new TypeError("dispatchEvent expects an event object");
+    }
+    const dispatchState = state ?? getEventState(event);
+    if (dispatchState.dispatchFlag || !dispatchState.initializedFlag) {
+      const message = "Failed to execute dispatchEvent: event is already being dispatched";
+      if (typeof globalThis.DOMException === "function") {
+        throw new globalThis.DOMException(message, "InvalidStateError");
+      }
+      const err = new Error(message);
+      err.name = "InvalidStateError";
+      throw err;
+    }
+    dispatchState.isTrusted = false;
+    dispatchState.dispatchFlag = true;
+    dispatchState.path = [
+      {
+        invocationTarget: target,
+        invocationTargetInShadowTree: false,
+        shadowAdjustedTarget: target,
+        relatedTarget: null,
+        touchTargets: [],
+        rootOfClosedTree: false,
+        slotInClosedTree: false
+      }
+    ];
+    notifyWildcardListeners(dispatchState.type, event);
+    const list = listeners.get(dispatchState.type);
+    const snapshot = list ? list.slice() : [];
+    invokeListeners(dispatchState.type, event, "capturing", snapshot);
+    invokeListeners(dispatchState.type, event, "bubbling", snapshot);
+    dispatchState.eventPhase = event.NONE;
+    dispatchState.currentTarget = null;
+    dispatchState.path = [];
+    dispatchState.dispatchFlag = false;
+    dispatchState.stopPropagationFlag = false;
+    dispatchState.stopImmediatePropagationFlag = false;
+    return !dispatchState.canceledFlag;
+  };
+  const removeEventListener = (type, listener, options2) => {
+    if (!listener)
+      return;
+    const capture = normalizeCaptureOption(options2);
+    const list = listeners.get(type);
+    if (!list)
+      return;
+    for (const record of [...list]) {
+      if (record.original === listener && record.capture === capture) {
+        removeListenerRecord(type, record);
+      }
+    }
+  };
+  const clear = () => {
+    for (const [type, list] of Array.from(listeners.entries())) {
+      for (const record of [...list]) {
+        removeListenerRecord(type, record);
+      }
+    }
+    listeners.clear();
+    for (const record of wildcardListeners) {
+      if (record.signal && record.abortHandler) {
+        record.signal.removeEventListener("abort", record.abortHandler);
+      }
+    }
+    wildcardListeners.clear();
+  };
+  const on = (type, options2) => {
+    return new Observable((observer) => {
+      let opts2;
+      if (typeof options2 === "boolean") {
+        opts2 = { capture: options2 };
+      } else {
+        opts2 = options2 ?? {};
+      }
+      const handler = opts2.handler;
+      const once = opts2.once;
+      const eventHandler = (e) => {
+        let success = false;
+        try {
+          if (handler) {
+            handler(e);
+          }
+          observer.next(e);
+          success = true;
+        } finally {
+          if (once && success) {
+            observer.complete();
+          }
+        }
+      };
+      const errorHandler = (e) => {
+        observer.error(e.detail);
+      };
+      const unsubscribeEvent = addEventListener(type, eventHandler, opts2);
+      let unsubscribeError;
+      if (opts2.receiveError) {
+        unsubscribeError = addEventListener("error", errorHandler, opts2);
+      }
+      return () => {
+        unsubscribeEvent();
+        if (unsubscribeError) {
+          unsubscribeError();
+        }
+      };
+    });
+  };
+  const onceMethod = (type, listener, options2) => {
+    if (typeof options2 === "boolean") {
+      return addEventListener(type, listener, { capture: options2, once: true });
+    }
+    return addEventListener(type, listener, { ...options2 ?? {}, once: true });
+  };
+  const removeAllListeners = (type) => {
+    if (type !== undefined) {
+      const list = listeners.get(type);
+      if (list) {
+        for (const record of [...list]) {
+          removeListenerRecord(type, record);
+        }
+        listeners.delete(type);
+      }
+    } else {
+      for (const [eventType, list] of Array.from(listeners.entries())) {
+        for (const record of [...list]) {
+          removeListenerRecord(eventType, record);
+        }
+      }
+      listeners.clear();
+      for (const record of wildcardListeners) {
+        if (record.signal && record.abortHandler) {
+          record.signal.removeEventListener("abort", record.abortHandler);
+        }
+      }
+      wildcardListeners.clear();
+    }
+  };
+  const pipe = (target2, mapFn) => {
+    if (isCompleted) {
+      return () => {};
+    }
+    const unsubscribe2 = addWildcardListener("*", (event) => {
+      if (mapFn) {
+        const mapped = mapFn(createEvent(event.originalType, event.detail, {
+          target: target2,
+          currentTarget: target2,
+          eventPhase: 2,
+          bubbles: event.bubbles,
+          cancelable: event.cancelable,
+          composed: event.composed
+        }));
+        if (mapped !== null) {
+          target2.dispatchEvent(mapped);
+        }
+      } else {
+        target2.dispatchEvent({
+          type: event.originalType,
+          detail: event.detail
+        });
+      }
+    });
+    const completionUnsub = () => {
+      unsubscribe2();
+    };
+    completionCallbacks.add(completionUnsub);
+    return () => {
+      completionCallbacks.delete(completionUnsub);
+      unsubscribe2();
+    };
+  };
+  const complete2 = () => {
+    if (isCompleted)
+      return;
+    isCompleted = true;
+    for (const cb of completionCallbacks) {
+      try {
+        cb();
+      } catch (err) {
+        try {
+          handleListenerError("complete", err);
+        } catch {}
+      }
+    }
+    completionCallbacks.clear();
+    for (const [eventType, list] of Array.from(listeners.entries())) {
+      for (const record of [...list]) {
+        removeListenerRecord(eventType, record);
+      }
+    }
+    listeners.clear();
+    for (const record of wildcardListeners) {
+      if (record.signal && record.abortHandler) {
+        record.signal.removeEventListener("abort", record.abortHandler);
+      }
+    }
+    wildcardListeners.clear();
+  };
+  const subscribe = (type, observerOrNext, error2, completeHandler) => {
+    let observer;
+    if (typeof observerOrNext === "function") {
+      observer = {
+        next: observerOrNext,
+        error: error2,
+        complete: completeHandler
+      };
+    } else {
+      observer = observerOrNext ?? {};
+    }
+    let closed = false;
+    if (isCompleted) {
+      if (observer.complete) {
+        try {
+          observer.complete();
+        } catch {}
+      }
+      return {
+        unsubscribe: () => {
+          closed = true;
+        },
+        get closed() {
+          return closed || isCompleted;
+        }
+      };
+    }
+    const unsub = addEventListener(type, (event) => {
+      if (closed)
+        return;
+      if (observer.next) {
+        try {
+          observer.next(event);
+        } catch (err) {
+          if (observer.error) {
+            try {
+              observer.error(err);
+            } catch {}
+          }
+        }
+      }
+    });
+    const onComplete = () => {
+      if (closed)
+        return;
+      closed = true;
+      if (observer.complete) {
+        try {
+          observer.complete();
+        } catch {}
+      }
+    };
+    completionCallbacks.add(onComplete);
+    return {
+      unsubscribe: () => {
+        if (closed)
+          return;
+        closed = true;
+        completionCallbacks.delete(onComplete);
+        unsub();
+      },
+      get closed() {
+        return closed || isCompleted;
+      }
+    };
+  };
+  const toObservable = () => {
+    return new Observable((observer) => {
+      if (isCompleted) {
+        observer.complete();
+        return;
+      }
+      const wildcardListener = (event) => {
+        observer.next(createEvent(event.originalType, event.detail, {
+          target,
+          currentTarget: target,
+          eventPhase: 2,
+          bubbles: event.bubbles,
+          cancelable: event.cancelable,
+          composed: event.composed
+        }));
+      };
+      const unsubscribe2 = addWildcardListener("*", wildcardListener);
+      const onComplete = () => {
+        observer.complete();
+      };
+      completionCallbacks.add(onComplete);
+      return () => {
+        unsubscribe2();
+        completionCallbacks.delete(onComplete);
+      };
+    });
+  };
+  function events(type, options2) {
+    if (isCompleted) {
+      return {
+        [Symbol.asyncIterator]() {
+          return this;
+        },
+        next() {
+          return Promise.resolve({
+            value: undefined,
+            done: true
+          });
+        },
+        return() {
+          return Promise.resolve({
+            value: undefined,
+            done: true
+          });
+        }
+      };
+    }
+    const signal = options2?.signal;
+    const bufferSize = options2?.bufferSize ?? Infinity;
+    const overflowStrategy = options2?.overflowStrategy ?? "drop-oldest";
+    const buffer = [];
+    let resolve = null;
+    let done = false;
+    let hasOverflow = false;
+    let onAbort = null;
+    const cleanupAbortListener = () => {
+      if (signal && onAbort) {
+        signal.removeEventListener("abort", onAbort);
+      }
+    };
+    const unsub = addEventListener(type, (event) => {
+      if (done)
+        return;
+      const typedEvent = event;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: typedEvent, done: false });
+      } else {
+        if (buffer.length >= bufferSize && bufferSize !== Infinity) {
+          switch (overflowStrategy) {
+            case "drop-oldest":
+              buffer.shift();
+              buffer.push(typedEvent);
+              break;
+            case "drop-latest":
+              break;
+            case "throw":
+              unsub();
+              completionCallbacks.delete(onComplete);
+              done = true;
+              hasOverflow = true;
+              cleanupAbortListener();
+              return;
+          }
+        } else {
+          buffer.push(typedEvent);
+        }
+      }
+    });
+    const onComplete = () => {
+      done = true;
+      cleanupAbortListener();
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: undefined, done: true });
+      }
+    };
+    completionCallbacks.add(onComplete);
+    if (signal) {
+      onAbort = () => {
+        done = true;
+        completionCallbacks.delete(onComplete);
+        unsub();
+        if (resolve) {
+          const r = resolve;
+          resolve = null;
+          r({ value: undefined, done: true });
+        }
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted)
+        onAbort();
+    }
+    const iterator = {
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      async next() {
+        if (buffer.length > 0) {
+          return { value: buffer.shift(), done: false };
+        }
+        if (resolve !== null) {
+          return Promise.reject(new Error("Concurrent calls to next() are not supported on this async iterator"));
+        }
+        return new Promise((_resolve, _reject) => {
+          if (hasOverflow) {
+            hasOverflow = false;
+            _reject(new BufferOverflowError(type, bufferSize));
+            return;
+          }
+          if (done) {
+            _resolve({
+              value: undefined,
+              done: true
+            });
+            return;
+          }
+          resolve = _resolve;
+        });
+      },
+      return() {
+        if (resolve) {
+          const r = resolve;
+          resolve = null;
+          r({ value: undefined, done: true });
+        }
+        done = true;
+        completionCallbacks.delete(onComplete);
+        unsub();
+        cleanupAbortListener();
+        return Promise.resolve({
+          value: undefined,
+          done: true
+        });
+      }
+    };
+    return iterator;
+  }
+  const target = {
+    addEventListener,
+    removeEventListener,
+    dispatchEvent,
+    clear,
+    on,
+    once: onceMethod,
+    removeAllListeners,
+    pipe,
+    addWildcardListener,
+    removeWildcardListener,
+    complete: complete2,
+    get completed() {
+      return isCompleted;
+    },
+    subscribe,
+    toObservable,
+    events
+  };
+  target[SymbolObservable] = () => {
+    return toObservable();
+  };
+  return target;
+}
+
+class EventEmission {
+  #target;
+  constructor() {
+    this.#target = createEventTarget();
+  }
+  addEventListener(type, listener, options2) {
+    return this.#target.addEventListener(type, listener, options2);
+  }
+  removeEventListener(type, listener, options2) {
+    this.#target.removeEventListener(type, listener, options2);
+  }
+  dispatchEvent(event) {
+    return this.#target.dispatchEvent(event);
+  }
+  on(type, options2) {
+    return this.#target.on(type, options2);
+  }
+  once(type, listener, options2) {
+    return this.#target.once(type, listener, options2);
+  }
+  removeAllListeners(type) {
+    this.#target.removeAllListeners(type);
+  }
+  clear() {
+    this.#target.clear();
+  }
+  pipe(target, mapFn) {
+    return this.#target.pipe(target, mapFn);
+  }
+  addWildcardListener(pattern, listener, options2) {
+    return this.#target.addWildcardListener(pattern, listener, options2);
+  }
+  removeWildcardListener(pattern, listener) {
+    this.#target.removeWildcardListener(pattern, listener);
+  }
+  subscribe(typeOrObserver, observerOrNext, error2, completeHandler) {
+    if (typeof typeOrObserver === "string") {
+      return this.#target.subscribe(typeOrObserver, observerOrNext, error2, completeHandler);
+    }
+    if (typeof typeOrObserver === "function") {
+      return this.#target.toObservable().subscribe(typeOrObserver);
+    }
+    if (typeof typeOrObserver === "object" && typeOrObserver !== null) {
+      const maybeObserver = typeOrObserver;
+      if (typeof maybeObserver.next === "function" || typeof maybeObserver.error === "function" || typeof maybeObserver.complete === "function") {
+        return this.#target.toObservable().subscribe(typeOrObserver);
+      }
+      return this.#target.toObservable().subscribe({});
+    }
+    throw new Error("subscribe() requires a string event type, callback function, or observer object");
+  }
+  toObservable() {
+    return this.#target.toObservable();
+  }
+  [SymbolObservable]() {
+    return this.toObservable();
+  }
+  complete() {
+    this.#target.complete();
+  }
+  get completed() {
+    return this.#target.completed;
+  }
+  events(type, options2) {
+    return this.#target.events(type, options2);
+  }
+}
+
+// src/errors.ts
+class ConversationalistError extends Error {
+  code;
+  context;
+  cause;
+  constructor(code, message, options2) {
+    super(message);
+    this.name = "ConversationalistError";
+    this.code = code;
+    this.context = options2?.context;
+    this.cause = options2?.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ConversationalistError);
+    }
+  }
+  toDetailedString() {
+    const parts = [`[${this.code}] ${this.message}`];
+    if (this.context && Object.keys(this.context).length > 0) {
+      parts.push(`Context: ${JSON.stringify(this.context, null, 2)}`);
+    }
+    if (this.cause) {
+      parts.push(`Caused by: ${this.cause.message}`);
+    }
+    return parts.join(`
+`);
+  }
+}
+function createInvalidPositionError(expected, actual) {
+  return new ConversationalistError("error:invalid-position", `invalid position: expected ${expected}, got ${actual}`, { context: { expected, actual } });
+}
+function createInvalidToolReferenceError(callId) {
+  return new ConversationalistError("error:invalid-tool-reference", `tool result references non-existent tool-use: ${callId}`, { context: { callId } });
+}
+function createSerializationError(message, cause) {
+  return new ConversationalistError("error:serialization", message, { cause });
+}
+function createValidationError(message, context, cause) {
+  return new ConversationalistError("error:validation", message, { context, cause });
+}
+function createIntegrityError(message, context) {
+  return new ConversationalistError("error:integrity", message, { context });
+}
+
+// src/schemas.ts
+import { z } from "zod";
+var isPlainObject = (value) => {
+  if (!value || typeof value !== "object")
+    return false;
+  const prototype = Reflect.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+function toMultiModalContent(value) {
+  const result = { type: value.type };
+  if (value.text !== undefined)
+    result.text = value.text;
+  if (value.url !== undefined)
+    result.url = value.url;
+  if (value.mimeType !== undefined)
+    result.mimeType = value.mimeType;
+  return result;
+}
+var jsonValueSchema = z.lazy(() => {
+  const jsonObjectSchema = z.preprocess((value, ctx) => {
+    if (!isPlainObject(value)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "expected a plain object"
+      });
+      return z.NEVER;
+    }
+    return value;
+  }, z.record(z.string(), jsonValueSchema));
+  return z.union([
+    z.string(),
+    z.number().refine((value) => Number.isFinite(value), {
+      message: "expected a finite number"
+    }),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    jsonObjectSchema
+  ]);
+});
+var multiModalContentSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("text"),
+    text: z.string()
+  }),
+  z.object({
+    type: z.literal("image"),
+    url: z.string().url(),
+    mimeType: z.string().optional(),
+    text: z.string().optional()
+  })
+]).transform(toMultiModalContent);
+var messageRoleSchema = z.enum([
+  "user",
+  "assistant",
+  "system",
+  "developer",
+  "tool-use",
+  "tool-result",
+  "snapshot"
+]);
+var toolCallSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  arguments: jsonValueSchema
+}).strict();
+var toolResultSchema = z.object({
+  callId: z.string(),
+  outcome: z.enum(["success", "error"]),
+  content: jsonValueSchema
+}).strict();
+var tokenUsageSchema = z.object({
+  prompt: z.number().int().min(0),
+  completion: z.number().int().min(0),
+  total: z.number().int().min(0)
+});
+var messageInputSchema = z.object({
+  role: messageRoleSchema,
+  content: z.union([z.string(), z.array(multiModalContentSchema)]),
+  metadata: z.record(z.string(), jsonValueSchema).optional(),
+  hidden: z.boolean().optional(),
+  toolCall: toolCallSchema.optional(),
+  toolResult: toolResultSchema.optional(),
+  tokenUsage: tokenUsageSchema.optional(),
+  goalCompleted: z.boolean().optional()
+}).strict();
+var messageSchema = z.object({
+  id: z.string(),
+  role: messageRoleSchema,
+  content: z.union([z.string(), z.array(multiModalContentSchema)]),
+  position: z.number().int().min(0),
+  createdAt: z.string(),
+  metadata: z.record(z.string(), jsonValueSchema),
+  hidden: z.boolean(),
+  toolCall: toolCallSchema.optional(),
+  toolResult: toolResultSchema.optional(),
+  tokenUsage: tokenUsageSchema.optional(),
+  goalCompleted: z.boolean().optional()
+}).strict();
+var conversationStatusSchema = z.enum([
+  "active",
+  "archived",
+  "deleted"
+]);
+var conversationShape = {
+  schemaVersion: z.number().int().min(1),
+  id: z.string(),
+  title: z.string().optional(),
+  status: conversationStatusSchema,
+  metadata: z.record(z.string(), jsonValueSchema),
+  ids: z.array(z.string()),
+  messages: z.record(z.string(), messageSchema),
+  createdAt: z.string(),
+  updatedAt: z.string()
+};
+var conversationSchema = z.object(conversationShape).strict();
+
+// src/conversation/integrity.ts
+function validateConversationIntegrity(conversation) {
+  const issues = [];
+  const seenIds = new Set;
+  conversation.ids.forEach((id, index) => {
+    if (seenIds.has(id)) {
+      issues.push({
+        code: "integrity:duplicate-message-id",
+        message: `duplicate message id in ids: ${id}`,
+        data: { id, position: index }
+      });
+    } else {
+      seenIds.add(id);
+    }
+    if (!conversation.messages[id]) {
+      issues.push({
+        code: "integrity:missing-message",
+        message: `missing message for id ${id}`,
+        data: { id, position: index }
+      });
+    }
+  });
+  for (const id of Object.keys(conversation.messages)) {
+    if (!seenIds.has(id)) {
+      issues.push({
+        code: "integrity:unlisted-message",
+        message: `message ${id} is not listed in ids`,
+        data: { id }
+      });
+    }
+  }
+  const toolUses = new Map;
+  conversation.ids.forEach((id, index) => {
+    const message = conversation.messages[id];
+    if (!message)
+      return;
+    if (message.role === "tool-use" && message.toolCall) {
+      if (toolUses.has(message.toolCall.id)) {
+        issues.push({
+          code: "integrity:duplicate-tool-call",
+          message: `duplicate toolCall.id ${message.toolCall.id}`,
+          data: { toolCallId: message.toolCall.id, messageId: message.id }
+        });
+      } else {
+        toolUses.set(message.toolCall.id, { position: index, messageId: message.id });
+      }
+    }
+  });
+  conversation.ids.forEach((id, index) => {
+    const message = conversation.messages[id];
+    if (!message)
+      return;
+    if (message.role === "tool-result" && message.toolResult) {
+      const toolUse = toolUses.get(message.toolResult.callId);
+      if (!toolUse) {
+        issues.push({
+          code: "integrity:orphan-tool-result",
+          message: `tool-result references missing tool-use ${message.toolResult.callId}`,
+          data: { callId: message.toolResult.callId, messageId: message.id }
+        });
+      } else if (toolUse.position >= index) {
+        issues.push({
+          code: "integrity:tool-result-before-call",
+          message: `tool-result ${message.toolResult.callId} occurs before tool-use`,
+          data: {
+            callId: message.toolResult.callId,
+            messageId: message.id,
+            toolUseMessageId: toolUse.messageId
+          }
+        });
+      }
+    }
+  });
+  return issues;
+}
+function assertConversationIntegrity(conversation) {
+  const issues = validateConversationIntegrity(conversation);
+  if (issues.length === 0)
+    return;
+  throw createIntegrityError("conversation integrity check failed", { issues });
+}
+
+// src/conversation/validation.ts
+function assertConversationSafe(conversation) {
+  const parsed = conversationSchema.safeParse(conversation);
+  if (!parsed.success) {
+    throw createValidationError("conversation failed schema validation", {
+      issues: parsed.error.issues
+    });
+  }
+  assertConversationIntegrity(conversation);
+}
+function ensureConversationSafe(conversation) {
+  assertConversationSafe(conversation);
+  return conversation;
+}
+
 // src/utilities/content.ts
 function normalizeContent(content) {
   if (content === undefined)
@@ -3655,6 +5422,92 @@ var cloneMessageWithPosition = (message, position, content) => {
   }
   return createMessage(baseMessage);
 };
+var createMessageBlock = (message, estimator) => ({
+  messages: [message],
+  minPosition: message.position,
+  maxPosition: message.position,
+  tokenCount: estimator(message)
+});
+var buildMessageBlocks = (messages, estimator, preserveToolPairs) => {
+  if (!preserveToolPairs) {
+    const blocks2 = messages.map((message) => createMessageBlock(message, estimator));
+    const messageToBlock2 = new Map;
+    for (const block of blocks2) {
+      const message = block.messages[0];
+      if (message) {
+        messageToBlock2.set(message.id, block);
+      }
+    }
+    return { blocks: blocks2, messageToBlock: messageToBlock2 };
+  }
+  const blocks = [];
+  const toolUses = new Map;
+  for (const message of messages) {
+    if (message.role === "tool-use" && message.toolCall) {
+      const block = createMessageBlock(message, estimator);
+      toolUses.set(message.toolCall.id, block);
+      blocks.push(block);
+      continue;
+    }
+    if (message.role === "tool-result" && message.toolResult) {
+      const existing = toolUses.get(message.toolResult.callId);
+      if (existing) {
+        existing.messages.push(message);
+        existing.maxPosition = Math.max(existing.maxPosition, message.position);
+        existing.tokenCount += estimator(message);
+        continue;
+      }
+      const orphanBlock = createMessageBlock(message, estimator);
+      orphanBlock.orphanToolResult = true;
+      blocks.push(orphanBlock);
+      continue;
+    }
+    blocks.push(createMessageBlock(message, estimator));
+  }
+  const filteredBlocks = blocks.filter((block) => !block.orphanToolResult);
+  const messageToBlock = new Map;
+  for (const block of filteredBlocks) {
+    for (const message of block.messages) {
+      messageToBlock.set(message.id, block);
+    }
+  }
+  return { blocks: filteredBlocks, messageToBlock };
+};
+var collectBlocksForMessages = (messages, messageToBlock) => {
+  const blocks = [];
+  const seen = new Set;
+  for (const message of messages) {
+    const block = messageToBlock.get(message.id);
+    if (block && !seen.has(block)) {
+      seen.add(block);
+      blocks.push(block);
+    }
+  }
+  return blocks;
+};
+var collectMessagesFromBlocks = (blocks) => {
+  const messages = [];
+  const seen = new Set;
+  for (const block of blocks) {
+    for (const message of block.messages) {
+      if (!seen.has(message.id)) {
+        seen.add(message.id);
+        messages.push(message);
+      }
+    }
+  }
+  messages.sort((a, b) => a.position - b.position);
+  return messages;
+};
+var ensureTruncationSafe = (conversation, preserveToolPairs, operation) => {
+  try {
+    return ensureConversationSafe(conversation);
+  } catch (error2) {
+    if (!preserveToolPairs && error2 instanceof ConversationalistError && error2.code === "error:integrity")
+      throw createIntegrityError(`${operation} produced invalid tool linkage; use preserveToolPairs: true to keep tool interactions intact`, { preserveToolPairs, issues: error2.context?.["issues"] });
+    throw error2;
+  }
+};
 function estimateConversationTokens(conversation, estimateTokens, environment) {
   let estimator = estimateTokens;
   let env = environment;
@@ -3667,6 +5520,7 @@ function estimateConversationTokens(conversation, estimateTokens, environment) {
   return getOrderedMessages(conversation).reduce((total, message) => total + finalEstimator(message), 0);
 }
 function truncateToTokenLimit(conversation, maxTokens, optionsOrEstimator, environment) {
+  assertConversationSafe(conversation);
   let options2 = {};
   let env = environment;
   if (typeof optionsOrEstimator === "function") {
@@ -3688,54 +5542,56 @@ function truncateToTokenLimit(conversation, maxTokens, optionsOrEstimator, envir
   const estimator = options2.estimateTokens ?? resolvedEnvironment.estimateTokens;
   const preserveSystem = options2.preserveSystemMessages ?? true;
   const preserveLastN = options2.preserveLastN ?? 0;
+  const preserveToolPairs = options2.preserveToolPairs ?? true;
   const currentTokens = estimateConversationTokens(conversation, estimator, resolvedEnvironment);
   if (currentTokens <= maxTokens) {
     return conversation;
   }
   const now = resolvedEnvironment.now();
   const orderedMessages = getOrderedMessages(conversation);
+  const { blocks, messageToBlock } = buildMessageBlocks(orderedMessages, estimator, preserveToolPairs);
   const systemMessages = preserveSystem ? orderedMessages.filter((m) => m.role === "system") : [];
   const nonSystemMessages = orderedMessages.filter((m) => m.role !== "system");
   const protectedMessages = preserveLastN > 0 ? nonSystemMessages.slice(-preserveLastN) : [];
-  const removableMessages = preserveLastN > 0 ? nonSystemMessages.slice(0, -preserveLastN) : nonSystemMessages;
-  const systemTokens = systemMessages.reduce((sum, m) => sum + estimator(m), 0);
-  const protectedTokens = protectedMessages.reduce((sum, m) => sum + estimator(m), 0);
+  const systemBlocks = collectBlocksForMessages(systemMessages, messageToBlock);
+  const protectedBlocks = collectBlocksForMessages(protectedMessages, messageToBlock);
+  const lockedBlocks = new Set([...systemBlocks, ...protectedBlocks]);
+  const removableBlocks = blocks.filter((block) => !lockedBlocks.has(block));
+  const systemTokens = systemBlocks.reduce((sum, block) => sum + block.tokenCount, 0);
+  const protectedTokens = protectedBlocks.reduce((sum, block) => sum + block.tokenCount, 0);
   const availableTokens = maxTokens - systemTokens - protectedTokens;
+  let selectedBlocks = [];
   if (availableTokens <= 0) {
-    const allMessages2 = [...systemMessages, ...protectedMessages];
-    const renumbered2 = allMessages2.map((message, index) => cloneMessageWithPosition(message, index, copyContent(message.content)));
-    return toReadonly({
-      ...conversation,
-      ids: renumbered2.map((message) => message.id),
-      messages: toIdRecord(renumbered2),
-      updatedAt: now
-    });
-  }
-  const keptRemovable = [];
-  let usedTokens = 0;
-  for (let i = removableMessages.length - 1;i >= 0; i--) {
-    const message = removableMessages[i];
-    const messageTokens = estimator(message);
-    if (usedTokens + messageTokens <= availableTokens) {
-      keptRemovable.unshift(message);
-      usedTokens += messageTokens;
-    } else {
-      break;
+    selectedBlocks = [...systemBlocks, ...protectedBlocks];
+  } else {
+    const sortedRemovable = [...removableBlocks].sort((a, b) => a.maxPosition - b.maxPosition);
+    const keptRemovable = [];
+    let usedTokens = 0;
+    for (let i = sortedRemovable.length - 1;i >= 0; i--) {
+      const block = sortedRemovable[i];
+      if (usedTokens + block.tokenCount <= availableTokens) {
+        keptRemovable.unshift(block);
+        usedTokens += block.tokenCount;
+      } else {
+        break;
+      }
     }
+    selectedBlocks = [...systemBlocks, ...keptRemovable, ...protectedBlocks];
   }
-  const allMessages = [...systemMessages, ...keptRemovable, ...protectedMessages];
-  allMessages.sort((a, b) => a.position - b.position);
+  const allMessages = collectMessagesFromBlocks(selectedBlocks);
   const renumbered = allMessages.map((message, index) => cloneMessageWithPosition(message, index, copyContent(message.content)));
-  return toReadonly({
+  const next2 = toReadonly({
     ...conversation,
     ids: renumbered.map((message) => message.id),
     messages: toIdRecord(renumbered),
     updatedAt: now
   });
+  return ensureTruncationSafe(next2, preserveToolPairs, "truncateToTokenLimit");
 }
 function getRecentMessages(conversation, count, options2) {
   const includeHidden = options2?.includeHidden ?? false;
   const includeSystem = options2?.includeSystem ?? false;
+  const preserveToolPairs = options2?.preserveToolPairs ?? true;
   const filtered = getOrderedMessages(conversation).filter((m) => {
     if (!includeHidden && m.hidden)
       return false;
@@ -3743,66 +5599,58 @@ function getRecentMessages(conversation, count, options2) {
       return false;
     return true;
   });
-  return filtered.slice(-count);
+  if (!preserveToolPairs) {
+    return filtered.slice(-count);
+  }
+  const { messageToBlock } = buildMessageBlocks(filtered, () => 0, preserveToolPairs);
+  const tail = filtered.slice(-count);
+  const blocks = collectBlocksForMessages(tail, messageToBlock);
+  return collectMessagesFromBlocks(blocks);
 }
 function truncateFromPosition(conversation, position, options2, environment) {
+  assertConversationSafe(conversation);
   const preserveSystem = options2?.preserveSystemMessages ?? true;
+  const preserveToolPairs = options2?.preserveToolPairs ?? true;
   const resolvedEnvironment = resolveConversationEnvironment(environment);
   const now = resolvedEnvironment.now();
   const ordered = getOrderedMessages(conversation);
+  const { messageToBlock } = buildMessageBlocks(ordered, () => 0, preserveToolPairs);
   const systemMessages = preserveSystem ? ordered.filter((m) => m.role === "system" && m.position < position) : [];
   const keptMessages = ordered.filter((m) => m.position >= position);
-  const allMessages = [...systemMessages, ...keptMessages];
+  const systemBlocks = collectBlocksForMessages(systemMessages, messageToBlock);
+  const keptBlocks = collectBlocksForMessages(keptMessages, messageToBlock);
+  const allMessages = collectMessagesFromBlocks([...systemBlocks, ...keptBlocks]);
   const renumbered = allMessages.map((message, index) => cloneMessageWithPosition(message, index, copyContent(message.content)));
-  return toReadonly({
+  const next2 = toReadonly({
     ...conversation,
     ids: renumbered.map((message) => message.id),
     messages: toIdRecord(renumbered),
     updatedAt: now
   });
-}
-
-// src/errors.ts
-class ConversationalistError extends Error {
-  code;
-  context;
-  cause;
-  constructor(code, message, options2) {
-    super(message);
-    this.name = "ConversationalistError";
-    this.code = code;
-    this.context = options2?.context;
-    this.cause = options2?.cause;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, ConversationalistError);
-    }
-  }
-  toDetailedString() {
-    const parts = [`[${this.code}] ${this.message}`];
-    if (this.context && Object.keys(this.context).length > 0) {
-      parts.push(`Context: ${JSON.stringify(this.context, null, 2)}`);
-    }
-    if (this.cause) {
-      parts.push(`Caused by: ${this.cause.message}`);
-    }
-    return parts.join(`
-`);
-  }
-}
-function createInvalidPositionError(expected, actual) {
-  return new ConversationalistError("error:invalid-position", `invalid position: expected ${expected}, got ${actual}`, { context: { expected, actual } });
-}
-function createInvalidToolReferenceError(callId) {
-  return new ConversationalistError("error:invalid-tool-reference", `tool result references non-existent tool-use: ${callId}`, { context: { callId } });
-}
-function createSerializationError(message, cause) {
-  return new ConversationalistError("error:serialization", message, { cause });
+  return ensureTruncationSafe(next2, preserveToolPairs, "truncateFromPosition");
 }
 
 // src/types.ts
 var CURRENT_SCHEMA_VERSION = 3;
 
-// src/conversation.ts
+// src/conversation/create.ts
+function createConversation(options2, environment) {
+  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const now = resolvedEnvironment.now();
+  const conv = {
+    schemaVersion: CURRENT_SCHEMA_VERSION,
+    id: options2?.id ?? resolvedEnvironment.randomId(),
+    title: options2?.title,
+    status: options2?.status ?? "active",
+    metadata: { ...options2?.metadata ?? {} },
+    ids: [],
+    messages: {},
+    createdAt: now,
+    updatedAt: now
+  };
+  return ensureConversationSafe(toReadonly(conv));
+}
+// src/conversation/tool-tracking.ts
 var buildToolUseIndex = (messages) => messages.reduce((index, message) => {
   if (message.role === "tool-use" && message.toolCall) {
     index.set(message.toolCall.id, { name: message.toolCall.name });
@@ -3810,53 +5658,43 @@ var buildToolUseIndex = (messages) => messages.reduce((index, message) => {
   return index;
 }, new Map);
 var registerToolUse = (index, toolCall) => {
-  const next = new Map(index);
-  next.set(toolCall.id, { name: toolCall.name });
-  return next;
+  const next2 = new Map(index);
+  next2.set(toolCall.id, { name: toolCall.name });
+  return next2;
 };
 var assertToolReference = (index, callId) => {
   if (!index.has(callId)) {
     throw createInvalidToolReferenceError(callId);
   }
 };
+
+// src/conversation/append.ts
 function partitionAppendArgs(args) {
-  if (args.length === 0) {
+  const filtered = args.filter((arg) => arg !== undefined);
+  if (filtered.length === 0) {
     return { inputs: [] };
   }
-  const last = args[args.length - 1];
+  const last = filtered[filtered.length - 1];
   if (isConversationEnvironmentParameter(last)) {
     return {
-      inputs: args.slice(0, -1),
+      inputs: filtered.slice(0, -1),
       environment: last
     };
   }
-  return { inputs: args };
-}
-function createConversation(options2, environment) {
-  const resolvedEnvironment = resolveConversationEnvironment(environment);
-  const now = resolvedEnvironment.now();
-  const conv = {
-    schemaVersion: CURRENT_SCHEMA_VERSION,
-    id: options2?.id ?? resolvedEnvironment.randomId(),
-    title: options2?.title,
-    status: options2?.status ?? "active",
-    metadata: { ...options2?.metadata ?? {} },
-    ids: [],
-    messages: {},
-    createdAt: now,
-    updatedAt: now
-  };
-  return toReadonly(conv);
+  return { inputs: filtered };
 }
 function appendMessages(conversation, ...args) {
+  return appendMessagesInternal(conversation, args, true);
+}
+var appendMessagesInternal = (conversation, args, validate) => {
   const { inputs, environment } = partitionAppendArgs(args);
   const resolvedEnvironment = resolveConversationEnvironment(environment);
   const now = resolvedEnvironment.now();
   const startPosition = conversation.ids.length;
-  const initialToolUses = buildToolUseIndex(getOrderedMessages(conversation));
+  const initialToolUses = validate ? buildToolUseIndex(getOrderedMessages(conversation)) : new Map;
   const { messages } = inputs.reduce((state, input, index) => {
     const processedInput = resolvedEnvironment.plugins.reduce((acc, plugin) => plugin(acc), input);
-    if (processedInput.role === "tool-result" && processedInput.toolResult) {
+    if (validate && processedInput.role === "tool-result" && processedInput.toolResult) {
       assertToolReference(state.toolUses, processedInput.toolResult.callId);
     }
     const normalizedContent = normalizeContent(processedInput.content);
@@ -3883,30 +5721,47 @@ function appendMessages(conversation, ...args) {
     } else {
       message = createMessage(baseMessage);
     }
-    const toolUses = processedInput.role === "tool-use" && processedInput.toolCall ? registerToolUse(state.toolUses, processedInput.toolCall) : state.toolUses;
+    let toolUses = state.toolUses;
+    if (processedInput.role === "tool-use" && processedInput.toolCall) {
+      if (validate && state.toolUses.has(processedInput.toolCall.id)) {
+        throw createIntegrityError("duplicate toolCall.id in conversation", {
+          toolCallId: processedInput.toolCall.id,
+          messageId: baseMessage.id
+        });
+      }
+      toolUses = validate ? registerToolUse(state.toolUses, processedInput.toolCall) : state.toolUses;
+    }
     return {
       toolUses,
       messages: [...state.messages, message]
     };
   }, { toolUses: initialToolUses, messages: [] });
   const messageIds = messages.map((message) => message.id);
-  const next = {
+  const next2 = {
     ...conversation,
     ids: [...conversation.ids, ...messageIds],
     messages: { ...conversation.messages, ...toIdRecord(messages) },
     updatedAt: now
   };
-  return toReadonly(next);
-}
+  const readonly = toReadonly(next2);
+  return validate ? ensureConversationSafe(readonly) : readonly;
+};
 function appendUserMessage(conversation, content, metadata, environment) {
-  return environment ? appendMessages(conversation, { role: "user", content, metadata }, environment) : appendMessages(conversation, { role: "user", content, metadata });
+  const resolvedEnvironment = isConversationEnvironmentParameter(metadata) ? metadata : environment;
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
+  return appendMessages(conversation, { role: "user", content, metadata: resolvedMetadata }, resolvedEnvironment);
 }
 function appendAssistantMessage(conversation, content, metadata, environment) {
-  return environment ? appendMessages(conversation, { role: "assistant", content, metadata }, environment) : appendMessages(conversation, { role: "assistant", content, metadata });
+  const resolvedEnvironment = isConversationEnvironmentParameter(metadata) ? metadata : environment;
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
+  return appendMessages(conversation, { role: "assistant", content, metadata: resolvedMetadata }, resolvedEnvironment);
 }
 function appendSystemMessage(conversation, content, metadata, environment) {
-  return environment ? appendMessages(conversation, { role: "system", content, metadata }, environment) : appendMessages(conversation, { role: "system", content, metadata });
+  const resolvedEnvironment = isConversationEnvironmentParameter(metadata) ? metadata : environment;
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
+  return appendMessages(conversation, { role: "system", content, metadata: resolvedMetadata }, resolvedEnvironment);
 }
+// src/conversation/query.ts
 function getMessages(conversation, options2) {
   const includeHidden = options2?.includeHidden ?? false;
   const ordered = getOrderedMessages(conversation);
@@ -3940,6 +5795,7 @@ function getStatistics(conversation) {
   }, { byRole: {}, hidden: 0, withImages: 0 });
   return { total: ordered.length, ...stats };
 }
+// src/conversation/system-messages.ts
 function hasSystemMessage(conversation) {
   return getOrderedMessages(conversation).some((m) => m.role === "system");
 }
@@ -3950,7 +5806,8 @@ function getSystemMessages(conversation) {
   return getOrderedMessages(conversation).filter((m) => m.role === "system");
 }
 function prependSystemMessage(conversation, content, metadata, environment) {
-  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const resolvedEnvironment = resolveConversationEnvironment(isConversationEnvironmentParameter(metadata) ? metadata : environment);
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
   const now = resolvedEnvironment.now();
   const newMessage = createMessage({
     id: resolvedEnvironment.randomId(),
@@ -3958,7 +5815,7 @@ function prependSystemMessage(conversation, content, metadata, environment) {
     content,
     position: 0,
     createdAt: now,
-    metadata: { ...metadata ?? {} },
+    metadata: { ...resolvedMetadata ?? {} },
     hidden: false,
     toolCall: undefined,
     toolResult: undefined,
@@ -3977,20 +5834,21 @@ function prependSystemMessage(conversation, content, metadata, environment) {
     toolResult: message.toolResult,
     tokenUsage: message.tokenUsage
   }));
-  return toReadonly({
+  return ensureConversationSafe(toReadonly({
     ...conversation,
     ids: [newMessage.id, ...ordered.map((message) => message.id)],
     messages: toIdRecord([newMessage, ...renumberedMessages]),
     updatedAt: now
-  });
+  }));
 }
 function replaceSystemMessage(conversation, content, metadata, environment) {
-  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const resolvedEnvironment = resolveConversationEnvironment(isConversationEnvironmentParameter(metadata) ? metadata : environment);
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
   const now = resolvedEnvironment.now();
   const ordered = getOrderedMessages(conversation);
   const firstSystemIndex = ordered.findIndex((m) => m.role === "system");
   if (firstSystemIndex === -1) {
-    return prependSystemMessage(conversation, content, metadata, resolvedEnvironment);
+    return prependSystemMessage(conversation, content, resolvedMetadata, resolvedEnvironment);
   }
   const original = ordered[firstSystemIndex];
   const replaced = createMessage({
@@ -3999,25 +5857,25 @@ function replaceSystemMessage(conversation, content, metadata, environment) {
     content,
     position: original.position,
     createdAt: original.createdAt,
-    metadata: { ...metadata ?? original.metadata },
+    metadata: { ...resolvedMetadata ?? original.metadata },
     hidden: original.hidden,
     toolCall: undefined,
     toolResult: undefined,
     tokenUsage: undefined
   });
-  const next = {
+  const next2 = {
     ...conversation,
     ids: [...conversation.ids],
     messages: { ...conversation.messages, [replaced.id]: replaced },
     updatedAt: now
   };
-  return toReadonly(next);
+  return ensureConversationSafe(toReadonly(next2));
 }
 function collapseSystemMessages(conversation, environment) {
   const ordered = getOrderedMessages(conversation);
   const systemMessages = ordered.filter((m) => m.role === "system");
   if (systemMessages.length <= 1) {
-    return conversation;
+    return ensureConversationSafe(conversation);
   }
   const resolvedEnvironment = resolveConversationEnvironment(environment);
   const now = resolvedEnvironment.now();
@@ -4067,15 +5925,48 @@ function collapseSystemMessages(conversation, environment) {
       tokenUsage: message.tokenUsage
     });
   });
-  const next = {
+  const next2 = {
     ...conversation,
     ids: renumbered.map((message) => message.id),
     messages: toIdRecord(renumbered),
     updatedAt: now
   };
-  return toReadonly(next);
+  return ensureConversationSafe(toReadonly(next2));
+}
+// src/utilities/tool-results.ts
+function copyToolResult(toolResult) {
+  return { ...toolResult };
+}
+function redactToolResult(toolResult, placeholder) {
+  return { ...toolResult, content: placeholder };
 }
-function redactMessageAtPosition(conversation, position, placeholder = "[REDACTED]", environment) {
+
+// src/conversation/modify.ts
+var isRedactMessageOptions = (value) => {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  return "placeholder" in candidate || "redactToolArguments" in candidate || "redactToolResults" in candidate || "clearToolMetadata" in candidate;
+};
+function redactMessageAtPosition(conversation, position, placeholderOrOptions, environment) {
+  let placeholder = "[REDACTED]";
+  let options2 = {};
+  let env = environment;
+  if (typeof placeholderOrOptions === "string") {
+    placeholder = placeholderOrOptions;
+  } else if (placeholderOrOptions) {
+    if (!environment && isConversationEnvironmentParameter(placeholderOrOptions)) {
+      env = placeholderOrOptions;
+    } else if (isRedactMessageOptions(placeholderOrOptions)) {
+      options2 = placeholderOrOptions;
+      if (options2.placeholder) {
+        placeholder = options2.placeholder;
+      }
+    }
+  }
+  const redactToolArguments = options2.redactToolArguments ?? true;
+  const redactToolResults = options2.redactToolResults ?? true;
+  const clearToolMetadata = options2.clearToolMetadata ?? false;
   if (position < 0 || position >= conversation.ids.length) {
     throw createInvalidPositionError(conversation.ids.length - 1, position);
   }
@@ -4084,6 +5975,22 @@ function redactMessageAtPosition(conversation, position, placeholder = "[REDACTE
   if (!original) {
     throw createInvalidPositionError(conversation.ids.length - 1, position);
   }
+  let toolCall = original.toolCall ? { ...original.toolCall } : undefined;
+  let toolResult = original.toolResult ? { ...original.toolResult } : undefined;
+  if (clearToolMetadata) {
+    toolCall = undefined;
+    toolResult = undefined;
+  } else {
+    if (original.role === "tool-use" && toolCall) {
+      toolCall = {
+        ...toolCall,
+        arguments: redactToolArguments ? placeholder : toolCall.arguments
+      };
+    }
+    if (original.role === "tool-result" && toolResult) {
+      toolResult = redactToolResults ? redactToolResult(toolResult, placeholder) : { ...toolResult };
+    }
+  }
   const redacted = createMessage({
     id: original.id,
     role: original.role,
@@ -4092,82 +5999,74 @@ function redactMessageAtPosition(conversation, position, placeholder = "[REDACTE
     createdAt: original.createdAt,
     metadata: { ...original.metadata },
     hidden: original.hidden,
-    toolCall: undefined,
-    toolResult: undefined,
-    tokenUsage: undefined
+    toolCall,
+    toolResult,
+    tokenUsage: original.tokenUsage ? { ...original.tokenUsage } : undefined
   });
-  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const resolvedEnvironment = resolveConversationEnvironment(env);
   const now = resolvedEnvironment.now();
-  const next = {
+  const next2 = {
     ...conversation,
     ids: [...conversation.ids],
     messages: { ...conversation.messages, [redacted.id]: redacted },
     updatedAt: now
   };
-  return toReadonly(next);
+  return ensureConversationSafe(toReadonly(next2));
 }
-function migrateConversation(json) {
-  if (typeof json !== "object" || json === null || Array.isArray(json)) {
-    return {
-      schemaVersion: CURRENT_SCHEMA_VERSION,
-      id: "",
-      status: "active",
-      metadata: {},
-      ids: [],
-      messages: {},
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString()
-    };
-  }
-  const data = json;
-  const rawMessages = data.messages;
-  let messages = {};
-  let ids = [];
-  const rawIds = data.ids;
-  const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
-  if (Array.isArray(rawMessages)) {
-    const rawMessageArray = rawMessages;
-    ids = rawMessageArray.map((message) => message.id);
-    messages = Object.fromEntries(rawMessageArray.map((message) => [message.id, message]));
-  } else if (rawMessages && typeof rawMessages === "object") {
-    messages = { ...rawMessages };
-    if (isStringArray(rawIds) && rawIds.length > 0) {
-      ids = [...rawIds];
-    } else {
-      ids = Object.values(messages).sort((a, b) => a.position - b.position).map((message) => message.id);
-    }
-  }
-  if (ids.length > 0) {
-    ids = ids.filter((id) => (id in messages));
-    const missing = Object.keys(messages).filter((id) => !ids.includes(id));
-    if (missing.length > 0) {
-      const sortedMissing = missing.sort((a, b) => (messages[a]?.position ?? 0) - (messages[b]?.position ?? 0));
-      ids = [...ids, ...sortedMissing];
-    }
-  }
-  if (!("schemaVersion" in json)) {
+// src/conversation/serialization.ts
+function normalizeToolResult(toolResult) {
+  if (!toolResult)
+    return;
+  return {
+    callId: toolResult.callId,
+    outcome: toolResult.outcome,
+    content: toolResult.content
+  };
+}
+function normalizeMessage(message) {
+  const base = {
+    id: message.id,
+    role: message.role,
+    content: message.content,
+    position: message.position,
+    createdAt: message.createdAt,
+    metadata: message.metadata,
+    hidden: message.hidden,
+    toolCall: message.toolCall ? { ...message.toolCall } : undefined,
+    toolResult: normalizeToolResult(message.toolResult),
+    tokenUsage: message.tokenUsage ? { ...message.tokenUsage } : undefined
+  };
+  if (isAssistantMessage(message)) {
     return {
-      ...data,
-      schemaVersion: CURRENT_SCHEMA_VERSION,
-      ids,
-      messages
+      ...base,
+      role: "assistant",
+      goalCompleted: message.goalCompleted
     };
   }
-  return { ...data, ids, messages };
+  return base;
 }
 function deserializeConversation(json) {
-  const migrated = migrateConversation(json);
+  const parsed = conversationSchema.safeParse(json);
+  if (!parsed.success) {
+    throw createSerializationError("failed to deserialize conversation: invalid data");
+  }
+  const data = parsed.data;
   try {
-    const orderedMessages = migrated.ids.map((id, index) => {
-      const message = migrated.messages[id];
+    const messageIds = new Set(Object.keys(data.messages));
+    const orderedMessages = data.ids.map((id, index) => {
+      const message = data.messages[id];
       if (!message) {
         throw createSerializationError(`missing message for id ${id}`);
       }
       if (message.position !== index) {
         throw createInvalidPositionError(index, message.position);
       }
-      return message;
+      messageIds.delete(id);
+      return normalizeMessage(message);
     });
+    if (messageIds.size > 0) {
+      throw createSerializationError(`messages not listed in ids: ${[...messageIds].join(", ")}`);
+    }
     orderedMessages.reduce((state, message) => {
       if (message.role === "tool-use" && message.toolCall) {
         return {
@@ -4179,24 +6078,28 @@ function deserializeConversation(json) {
       }
       return state;
     }, { toolUses: new Map });
-    const messageInstances = orderedMessages.map((m) => createMessage(m));
+    const messageInstances = orderedMessages.map((message) => createMessage(message));
     const conv = {
-      schemaVersion: migrated.schemaVersion,
-      id: migrated.id,
-      title: migrated.title,
-      status: migrated.status,
-      metadata: { ...migrated.metadata },
+      schemaVersion: data.schemaVersion,
+      id: data.id,
+      title: data.title,
+      status: data.status,
+      metadata: { ...data.metadata },
       ids: orderedMessages.map((message) => message.id),
       messages: toIdRecord(messageInstances),
-      createdAt: migrated.createdAt,
-      updatedAt: migrated.updatedAt
+      createdAt: data.createdAt,
+      updatedAt: data.updatedAt
     };
-    return toReadonly(conv);
-  } catch (error) {
-    throw createSerializationError(`failed to deserialize conversation: ${error instanceof Error ? error.message : String(error)}`, error);
+    const readonly = toReadonly(conv);
+    assertConversationIntegrity(readonly);
+    return readonly;
+  } catch (error2) {
+    throw createSerializationError(`failed to deserialize conversation: ${error2 instanceof Error ? error2.message : String(error2)}`, error2);
   }
 }
+// src/conversation/transform.ts
 function toChatMessages(conversation) {
+  assertConversationSafe(conversation);
   const roleMap = {
     user: "user",
     assistant: "assistant",
@@ -4218,7 +6121,6 @@ function toChatMessages(conversation) {
   }
   return result;
 }
-
 // src/streaming.ts
 var STREAMING_KEY = "__streaming";
 var cloneMessage = (original, overrides = {}) => {
@@ -4251,7 +6153,8 @@ function getStreamingMessage(conversation) {
   return getOrderedMessages(conversation).find(isStreamingMessage);
 }
 function appendStreamingMessage(conversation, role, metadata, environment) {
-  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const resolvedEnvironment = resolveConversationEnvironment(isConversationEnvironmentParameter(metadata) ? metadata : environment);
+  const resolvedMetadata = isConversationEnvironmentParameter(metadata) ? undefined : metadata;
   const now = resolvedEnvironment.now();
   const messageId = resolvedEnvironment.randomId();
   const newMessage = createMessage({
@@ -4260,7 +6163,7 @@ function appendStreamingMessage(conversation, role, metadata, environment) {
     content: "",
     position: conversation.ids.length,
     createdAt: now,
-    metadata: { ...metadata ?? {}, [STREAMING_KEY]: true },
+    metadata: { ...resolvedMetadata ?? {}, [STREAMING_KEY]: true },
     hidden: false,
     toolCall: undefined,
     toolResult: undefined,
@@ -4272,14 +6175,14 @@ function appendStreamingMessage(conversation, role, metadata, environment) {
     messages: { ...conversation.messages, [messageId]: newMessage },
     updatedAt: now
   });
-  return { conversation: updatedConversation, messageId };
+  return { conversation: ensureConversationSafe(updatedConversation), messageId };
 }
 function updateStreamingMessage(conversation, messageId, content, environment) {
   const resolvedEnvironment = resolveConversationEnvironment(environment);
   const now = resolvedEnvironment.now();
   const original = conversation.messages[messageId];
   if (!original) {
-    return conversation;
+    return ensureConversationSafe(conversation);
   }
   const overrides = {
     content: typeof content === "string" ? content : [...content]
@@ -4288,44 +6191,45 @@ function updateStreamingMessage(conversation, messageId, content, environment) {
     overrides.tokenUsage = { ...original.tokenUsage };
   }
   const updated = cloneMessage(original, overrides);
-  return toReadonly({
+  return ensureConversationSafe(toReadonly({
     ...conversation,
     ids: [...conversation.ids],
     messages: { ...conversation.messages, [updated.id]: updated },
     updatedAt: now
-  });
+  }));
 }
 function finalizeStreamingMessage(conversation, messageId, options2, environment) {
-  const resolvedEnvironment = resolveConversationEnvironment(environment);
+  const resolvedEnvironment = resolveConversationEnvironment(isConversationEnvironmentParameter(options2) ? options2 : environment);
+  const resolvedOptions = isConversationEnvironmentParameter(options2) ? undefined : options2;
   const now = resolvedEnvironment.now();
   const original = conversation.messages[messageId];
   if (!original) {
-    return conversation;
+    return ensureConversationSafe(conversation);
   }
   const { [STREAMING_KEY]: _, ...restMetadata } = original.metadata;
   const finalMetadata = {
     ...restMetadata,
-    ...options2?.metadata ?? {}
+    ...resolvedOptions?.metadata ?? {}
   };
   const finalizeOverrides = {
     metadata: finalMetadata
   };
-  if (options2?.tokenUsage) {
-    finalizeOverrides.tokenUsage = { ...options2.tokenUsage };
+  if (resolvedOptions?.tokenUsage) {
+    finalizeOverrides.tokenUsage = { ...resolvedOptions.tokenUsage };
   }
   const updated = cloneMessage(original, finalizeOverrides);
-  return toReadonly({
+  return ensureConversationSafe(toReadonly({
     ...conversation,
     ids: [...conversation.ids],
     messages: { ...conversation.messages, [updated.id]: updated },
     updatedAt: now
-  });
+  }));
 }
 function cancelStreamingMessage(conversation, messageId, environment) {
   const resolvedEnvironment = resolveConversationEnvironment(environment);
   const now = resolvedEnvironment.now();
   if (!conversation.messages[messageId]) {
-    return conversation;
+    return ensureConversationSafe(conversation);
   }
   const messages = getOrderedMessages(conversation).filter((m) => m.id !== messageId).map((message, index) => message.position === index ? message : (() => {
     const overrides = {
@@ -4336,29 +6240,26 @@ function cancelStreamingMessage(conversation, messageId, environment) {
     }
     return cloneMessage(message, overrides);
   })());
-  return toReadonly({
+  return ensureConversationSafe(toReadonly({
     ...conversation,
     ids: messages.map((message) => message.id),
     messages: toIdRecord(messages),
     updatedAt: now
-  });
+  }));
 }
 
 // src/history.ts
-class ConversationHistoryEvent extends CustomEvent {
-  constructor(type, detail) {
-    super(type, { detail });
-  }
-}
-
 class ConversationHistory extends EventTarget {
   currentNode;
   environment;
+  events;
   constructor(initial = createConversation(), environment) {
     super();
     this.environment = resolveConversationEnvironment(environment);
+    this.events = createEventTarget();
+    const safeInitial = ensureConversationSafe(initial);
     this.currentNode = {
-      conversation: initial,
+      conversation: safeInitial,
       parent: null,
       children: []
     };
@@ -4368,25 +6269,54 @@ class ConversationHistory extends EventTarget {
       type,
       conversation: this.current
     };
-    this.dispatchEvent(new ConversationHistoryEvent("change", detail));
-    this.dispatchEvent(new ConversationHistoryEvent(type, detail));
+    this.events.dispatchEvent({ type: "change", detail });
+    this.events.dispatchEvent({ type, detail });
+  }
+  toAddListenerOptions(options2) {
+    if (typeof options2 === "boolean" || options2 === undefined)
+      return options2;
+    const mapped = {};
+    if (options2.capture !== undefined)
+      mapped.capture = options2.capture;
+    if (options2.once !== undefined)
+      mapped.once = options2.once;
+    if (options2.passive !== undefined)
+      mapped.passive = options2.passive;
+    if (options2.signal !== undefined) {
+      mapped.signal = options2.signal;
+    }
+    return mapped;
+  }
+  toRemoveListenerOptions(options2) {
+    if (typeof options2 === "boolean" || options2 === undefined)
+      return options2;
+    const mapped = {};
+    if (options2.capture !== undefined)
+      mapped.capture = options2.capture;
+    return mapped;
   }
   addEventListener(type, callback, options2) {
     if (!callback)
       return;
-    super.addEventListener(type, callback, options2);
-    const unsubscribe = () => this.removeEventListener(type, callback, options2);
-    return unsubscribe;
+    return this.events.addEventListener(type, callback, this.toAddListenerOptions(options2));
+  }
+  removeEventListener(type, callback, options2) {
+    if (!callback)
+      return;
+    this.events.removeEventListener(type, callback, this.toRemoveListenerOptions(options2));
+  }
+  dispatchEvent(event) {
+    return this.events.dispatchEvent(event);
   }
   subscribe(run) {
     run(this.current);
     const handler = (event) => {
-      if (event instanceof ConversationHistoryEvent) {
+      if (event?.detail?.conversation) {
         run(event.detail.conversation);
       }
     };
-    const unsubscribe = this.addEventListener("change", handler);
-    return unsubscribe || (() => {});
+    const unsubscribe2 = this.addEventListener("change", handler);
+    return unsubscribe2 || (() => {});
   }
   getSnapshot() {
     return this.current;
@@ -4417,9 +6347,9 @@ class ConversationHistory extends EventTarget {
   get redoCount() {
     return this.currentNode.children.length;
   }
-  push(next) {
+  push(next2) {
     const newNode = {
-      conversation: next,
+      conversation: next2,
       parent: this.currentNode,
       children: []
     };
@@ -4436,9 +6366,9 @@ class ConversationHistory extends EventTarget {
     return;
   }
   redo(childIndex = 0) {
-    const next = this.currentNode.children[childIndex];
-    if (next) {
-      this.currentNode = next;
+    const next2 = this.currentNode.children[childIndex];
+    if (next2) {
+      this.currentNode = next2;
       this.notifyChange("redo");
       return this.current;
     }
@@ -4527,8 +6457,8 @@ class ConversationHistory extends EventTarget {
   collapseSystemMessages() {
     this.push(collapseSystemMessages(this.current, this.env));
   }
-  redactMessageAtPosition(position, placeholder) {
-    this.push(redactMessageAtPosition(this.current, position, placeholder, this.env));
+  redactMessageAtPosition(position, placeholderOrOptions) {
+    this.push(redactMessageAtPosition(this.current, position, placeholderOrOptions, this.env));
   }
   truncateFromPosition(position, options2) {
     this.push(truncateFromPosition(this.current, position, options2, this.env));
@@ -4625,6 +6555,7 @@ class ConversationHistory extends EventTarget {
     };
     if (root)
       clearNode(root);
+    this.events.clear();
   }
 }
 function isConversation(value) {
@@ -4633,23 +6564,6 @@ function isConversation(value) {
 
 // src/utilities/markdown.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
-
-// src/utilities/tool-results.ts
-function copyToolResult(toolResult) {
-  return { ...toolResult };
-}
-function redactToolResult(toolResult, placeholder) {
-  const result = { ...toolResult, content: placeholder };
-  if (result.result !== undefined) {
-    result.result = placeholder;
-  }
-  if (result.error !== undefined) {
-    result.error = placeholder;
-  }
-  return result;
-}
-
-// src/utilities/markdown.ts
 var ROLE_LABELS = {
   user: "User",
   assistant: "Assistant",
@@ -4659,7 +6573,6 @@ var ROLE_LABELS = {
   "tool-result": "Tool Result",
   snapshot: "Snapshot"
 };
-var ROLE_DISPLAY_NAMES = ROLE_LABELS;
 var LABEL_TO_ROLE = {
   User: "user",
   Assistant: "assistant",
@@ -4669,7 +6582,6 @@ var LABEL_TO_ROLE = {
   "Tool Result": "tool-result",
   Snapshot: "snapshot"
 };
-var DISPLAY_NAME_TO_ROLE = LABEL_TO_ROLE;
 function getRoleLabel(role) {
   return ROLE_LABELS[role];
 }
@@ -4752,6 +6664,7 @@ function formatMessageContent(message) {
 `);
 }
 function toMarkdown(conversation, options2 = {}) {
+  assertConversationSafe(conversation);
   const resolved = resolveMarkdownOptions(options2);
   const prepared = prepareConversationForMarkdown(conversation, resolved);
   if (resolved.includeMetadata) {
@@ -4762,7 +6675,7 @@ function toMarkdown(conversation, options2 = {}) {
 function toMarkdownSimple(conversation) {
   const sections = [];
   for (const message of getOrderedMessages(conversation)) {
-    const roleName = ROLE_DISPLAY_NAMES[message.role];
+    const roleName = ROLE_LABELS[message.role];
     const header = `### ${roleName}`;
     const content = formatMessageContent(message);
     sections.push(`${header}
@@ -4813,7 +6726,7 @@ function toMarkdownWithMetadata(conversation, _options) {
   }
   const messageSections = [];
   for (const message of getOrderedMessages(conversation)) {
-    const roleName = ROLE_DISPLAY_NAMES[message.role];
+    const roleName = ROLE_LABELS[message.role];
     const header = `### ${roleName} (${message.id})`;
     const content = formatMessageContent(message);
     messageSections.push(`${header}
@@ -4838,10 +6751,13 @@ function generateId() {
 function fromMarkdown(markdown) {
   const trimmed = markdown.trim();
   const hasFrontmatter = trimmed.startsWith("---");
-  if (hasFrontmatter) {
-    return parseMarkdownWithMetadata(trimmed);
+  const conversation = hasFrontmatter ? parseMarkdownWithMetadata(trimmed) : parseMarkdownSimple(trimmed);
+  try {
+    assertConversationSafe(conversation);
+  } catch (error2) {
+    throw new MarkdownParseError(`Invalid markdown conversation: ${error2 instanceof Error ? error2.message : String(error2)}`);
   }
-  return parseMarkdownSimple(trimmed);
+  return conversation;
 }
 function parseMarkdownWithMetadata(trimmed) {
   let parsed;
@@ -4860,7 +6776,7 @@ function parseMarkdownWithMetadata(trimmed) {
   let match;
   while ((match = messagePattern.exec(body)) !== null) {
     const [, roleDisplay, messageId, contentBody] = match;
-    const role = DISPLAY_NAME_TO_ROLE[roleDisplay];
+    const role = LABEL_TO_ROLE[roleDisplay];
     if (!role) {
       throw new MarkdownParseError(`Unknown role: ${roleDisplay}`);
     }
@@ -4917,7 +6833,7 @@ function parseMarkdownSimple(body) {
   let position = 0;
   while ((match = messagePattern.exec(body)) !== null) {
     const [, roleDisplay, contentBody] = match;
-    const role = DISPLAY_NAME_TO_ROLE[roleDisplay];
+    const role = LABEL_TO_ROLE[roleDisplay];
     if (!role) {
       throw new MarkdownParseError(`Unknown role: ${roleDisplay}`);
     }
@@ -4966,4 +6882,4 @@ export {
   LABEL_TO_ROLE
 };
 
-//# debugId=958A518551DE0FA964756E2164756E21
+//# debugId=C9F3624DCBE2A76564756E2164756E21