@alistigo/claude-storage-plugin 0.2.10

package/dist/index.js

@@ -0,0 +1,1169 @@
+class Q extends Error {
+  constructor(n) {
+    super(n), this.name = "ListError";
+  }
+}
+class ke extends Q {
+  constructor(n) {
+    super(`ListElement not found: ${n}`), this.name = "ListElementNotFoundError";
+  }
+}
+const De = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+function Ue(e) {
+  return typeof e == "string" && De.test(e);
+}
+var w = [];
+for (var ne = 0; ne < 256; ++ne)
+  w.push((ne + 256).toString(16).slice(1));
+function Ie(e, n = 0) {
+  return (w[e[n + 0]] + w[e[n + 1]] + w[e[n + 2]] + w[e[n + 3]] + "-" + w[e[n + 4]] + w[e[n + 5]] + "-" + w[e[n + 6]] + w[e[n + 7]] + "-" + w[e[n + 8]] + w[e[n + 9]] + "-" + w[e[n + 10]] + w[e[n + 11]] + w[e[n + 12]] + w[e[n + 13]] + w[e[n + 14]] + w[e[n + 15]]).toLowerCase();
+}
+function Pe(e, n = 0) {
+  var t = Ie(e, n);
+  if (!Ue(t))
+    throw TypeError("Stringified UUID is invalid");
+  return t;
+}
+var G, $e = new Uint8Array(16);
+function Fe() {
+  if (!G && (G = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !G))
+    throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return G($e);
+}
+var me = null, he = null, A = 0;
+function Re(e, n, t) {
+  e = e || {};
+  var i = 0, c = n || new Uint8Array(16), m = e.random || (e.rng || Fe)(), _ = e.msecs !== void 0 ? e.msecs : Date.now(), I = e.seq !== void 0 ? e.seq : null, E = he, p = me;
+  return _ > A && e.msecs === void 0 && (A = _, I !== null && (E = null, p = null)), I !== null && (I > 2147483647 && (I = 2147483647), E = I >>> 19 & 4095, p = I & 524287), (E === null || p === null) && (E = m[6] & 127, E = E << 8 | m[7], p = m[8] & 63, p = p << 8 | m[9], p = p << 5 | m[10] >>> 3), _ + 1e4 > A && I === null ? ++p > 524287 && (p = 0, ++E > 4095 && (E = 0, A++)) : A = _, he = E, me = p, c[i++] = A / 1099511627776 & 255, c[i++] = A / 4294967296 & 255, c[i++] = A / 16777216 & 255, c[i++] = A / 65536 & 255, c[i++] = A / 256 & 255, c[i++] = A & 255, c[i++] = E >>> 4 & 15 | 112, c[i++] = E & 255, c[i++] = p >>> 13 & 63 | 128, c[i++] = p >>> 5 & 255, c[i++] = p << 3 & 255 | m[10] & 7, c[i++] = m[11], c[i++] = m[12], c[i++] = m[13], c[i++] = m[14], c[i++] = m[15], n || Ie(c);
+}
+function Ve(e) {
+  let n;
+  const t = new Uint8Array(16);
+  return t[0] = (n = parseInt(e.slice(0, 8), 16)) >>> 24, t[1] = n >>> 16 & 255, t[2] = n >>> 8 & 255, t[3] = n & 255, t[4] = (n = parseInt(e.slice(9, 13), 16)) >>> 8, t[5] = n & 255, t[6] = (n = parseInt(e.slice(14, 18), 16)) >>> 8, t[7] = n & 255, t[8] = (n = parseInt(e.slice(19, 23), 16)) >>> 8, t[9] = n & 255, t[10] = (n = parseInt(e.slice(24, 36), 16)) / 1099511627776 & 255, t[11] = n / 4294967296 & 255, t[12] = n >>> 24 & 255, t[13] = n >>> 16 & 255, t[14] = n >>> 8 & 255, t[15] = n & 255, t;
+}
+var h = "0123456789abcdefghjkmnpqrstvwxyz", s = new Uint8Array([
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  255,
+  18,
+  19,
+  255,
+  20,
+  21,
+  255,
+  22,
+  23,
+  24,
+  25,
+  26,
+  255,
+  27,
+  28,
+  29,
+  30,
+  31,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255
+]);
+function ie(e) {
+  const n = new Array(26).fill("");
+  if (e.length !== 16)
+    throw new Error(
+      `Invalid length. Expected 16 bytes, got ${e.length}. Input: ${e}`
+    );
+  return n[0] = h[(e[0] & 224) >> 5], n[1] = h[e[0] & 31], n[2] = h[(e[1] & 248) >> 3], n[3] = h[(e[1] & 7) << 2 | (e[2] & 192) >> 6], n[4] = h[(e[2] & 62) >> 1], n[5] = h[(e[2] & 1) << 4 | (e[3] & 240) >> 4], n[6] = h[(e[3] & 15) << 1 | (e[4] & 128) >> 7], n[7] = h[(e[4] & 124) >> 2], n[8] = h[(e[4] & 3) << 3 | (e[5] & 224) >> 5], n[9] = h[e[5] & 31], n[10] = h[(e[6] & 248) >> 3], n[11] = h[(e[6] & 7) << 2 | (e[7] & 192) >> 6], n[12] = h[(e[7] & 62) >> 1], n[13] = h[(e[7] & 1) << 4 | (e[8] & 240) >> 4], n[14] = h[(e[8] & 15) << 1 | (e[9] & 128) >> 7], n[15] = h[(e[9] & 124) >> 2], n[16] = h[(e[9] & 3) << 3 | (e[10] & 224) >> 5], n[17] = h[e[10] & 31], n[18] = h[(e[11] & 248) >> 3], n[19] = h[(e[11] & 7) << 2 | (e[12] & 192) >> 6], n[20] = h[(e[12] & 62) >> 1], n[21] = h[(e[12] & 1) << 4 | (e[13] & 240) >> 4], n[22] = h[(e[13] & 15) << 1 | (e[14] & 128) >> 7], n[23] = h[(e[14] & 124) >> 2], n[24] = h[(e[14] & 3) << 3 | (e[15] & 224) >> 5], n[25] = h[e[15] & 31], n.join("");
+}
+function xe(e) {
+  if (e.length !== 26)
+    throw new Error(
+      `Invalid length. Expected 26 bytes, got ${e.length}. Input: ${e}`
+    );
+  const t = new TextEncoder().encode(e);
+  if (s[t[0]] === 255 || s[t[1]] === 255 || s[t[2]] === 255 || s[t[3]] === 255 || s[t[4]] === 255 || s[t[5]] === 255 || s[t[6]] === 255 || s[t[7]] === 255 || s[t[8]] === 255 || s[t[9]] === 255 || s[t[10]] === 255 || s[t[11]] === 255 || s[t[12]] === 255 || s[t[13]] === 255 || s[t[14]] === 255 || s[t[15]] === 255 || s[t[16]] === 255 || s[t[17]] === 255 || s[t[18]] === 255 || s[t[19]] === 255 || s[t[20]] === 255 || s[t[21]] === 255 || s[t[22]] === 255 || s[t[23]] === 255 || s[t[24]] === 255 || s[t[25]] === 255)
+    throw new Error("Invalid base32 character");
+  const i = new Uint8Array(16);
+  return i[0] = s[t[0]] << 5 | s[t[1]], i[1] = s[t[2]] << 3 | s[t[3]] >> 2, i[2] = (s[t[3]] & 3) << 6 | s[t[4]] << 1 | s[t[5]] >> 4, i[3] = (s[t[5]] & 15) << 4 | s[t[6]] >> 1, i[4] = (s[t[6]] & 1) << 7 | s[t[7]] << 2 | s[t[8]] >> 3, i[5] = (s[t[8]] & 7) << 5 | s[t[9]], i[6] = s[t[10]] << 3 | s[t[11]] >> 2, i[7] = (s[t[11]] & 3) << 6 | s[t[12]] << 1 | s[t[13]] >> 4, i[8] = (s[t[13]] & 15) << 4 | s[t[14]] >> 1, i[9] = (s[t[14]] & 1) << 7 | s[t[15]] << 2 | s[t[16]] >> 3, i[10] = (s[t[16]] & 7) << 5 | s[t[17]], i[11] = s[t[18]] << 3 | s[t[19]] >> 2, i[12] = (s[t[19]] & 3) << 6 | s[t[20]] << 1 | s[t[21]] >> 4, i[13] = (s[t[21]] & 15) << 4 | s[t[22]] >> 1, i[14] = (s[t[22]] & 1) << 7 | s[t[23]] << 2 | s[t[24]] >> 3, i[15] = (s[t[24]] & 7) << 5 | s[t[25]], i;
+}
+function qe(e) {
+  if (e.length > 63)
+    return !1;
+  let n, t, i;
+  for (t = 0, i = e.length; t < i; t += 1) {
+    n = e.charCodeAt(t);
+    const c = n > 96 && n < 123, m = n === 95;
+    if ((t === 0 || t === i - 1) && !c || !(c || m))
+      return !1;
+  }
+  return !0;
+}
+var Ne = class extends Error {
+  constructor(e) {
+    super(`Invalid prefix "${e}". Must be at most 63 ASCII letters [a-z_]`), this.name = "InvalidPrefixError";
+  }
+}, Me = class extends Error {
+  constructor(e, n) {
+    super(`Invalid TypeId. Prefix mismatch. Expected ${e}, got ${n}`), this.name = "PrefixMismatchError";
+  }
+}, Be = class extends Error {
+  constructor(e) {
+    super(`Invalid TypeId. Prefix cannot be empty when there's a separator: ${e}`), this.name = "EmptyPrefixError";
+  }
+}, Le = class extends Error {
+  constructor(e) {
+    super(`Invalid length. Suffix should have 26 characters, got ${e}`), this.name = "InvalidSuffixLengthError";
+  }
+}, He = class extends Error {
+  constructor(e) {
+    super(`Invalid suffix. First character "${e}" must be in the range [0-7]`), this.name = "InvalidSuffixCharacterError";
+  }
+}, Ge = class extends Error {
+  constructor(e, n) {
+    super(`Cannot convert TypeID of type ${e} to type ${n}`), this.name = "TypeIDConversionError";
+  }
+};
+function Se(e = "", n = "") {
+  if (!qe(e))
+    throw new Ne(e);
+  let t;
+  if (n)
+    t = n;
+  else {
+    const i = new Uint8Array(16);
+    Re(void 0, i), t = ie(i);
+  }
+  if (t.length !== 26)
+    throw new Le(t.length);
+  if (t[0] > "7")
+    throw new He(t[0]);
+  return xe(t), e === "" ? t : `${e}_${t}`;
+}
+function Ke(e, n) {
+  let t, i;
+  const c = e.lastIndexOf("_");
+  if (c === -1)
+    t = "", i = e;
+  else if (t = e.substring(0, c), i = e.substring(c + 1), !t)
+    throw new Be(e);
+  if (!i)
+    throw new Le(0);
+  if (n && t !== n)
+    throw new Me(n, t);
+  return Se(t, i);
+}
+function ge(e) {
+  const n = e.lastIndexOf("_");
+  return n === -1 ? "" : e.substring(0, n);
+}
+function ve(e) {
+  const n = e.lastIndexOf("_");
+  return n === -1 ? e : e.substring(n + 1);
+}
+var D = class {
+  constructor(e, n = "") {
+    this.prefix = e, this.suffix = n;
+    const t = Se(e, n);
+    this.prefix = ge(t), this.suffix = ve(t);
+  }
+  getType() {
+    return this.prefix;
+  }
+  getSuffix() {
+    return this.suffix;
+  }
+  asType(e) {
+    const n = this;
+    if (n.prefix !== e)
+      throw new Ge(n.prefix, e);
+    return n;
+  }
+  toUUIDBytes() {
+    return xe(this.suffix);
+  }
+  toUUID() {
+    return Pe(this.toUUIDBytes());
+  }
+  toString() {
+    return this.prefix === "" ? this.suffix : `${this.prefix}_${this.suffix}`;
+  }
+  static fromString(e, n) {
+    const t = Ke(e, n);
+    return new D(ge(t), ve(t));
+  }
+  static fromUUIDBytes(e, n) {
+    const t = ie(n);
+    return new D(e, t);
+  }
+  static fromUUID(e, n) {
+    const t = ie(Ve(n));
+    return new D(e, t);
+  }
+};
+function se(e = "", n = "") {
+  return new D(e, n);
+}
+function Je() {
+  return se("lse");
+}
+function pe(e) {
+  return D.fromString(e, "lse");
+}
+function K() {
+  return se("lev");
+}
+function Xe(e) {
+  return D.fromString(e, "lev");
+}
+function Qe() {
+  return se("lst");
+}
+function Oe(e) {
+  return D.fromString(e, "lst");
+}
+function We(e) {
+  const n = new Date(e);
+  if (Number.isNaN(n.getTime()))
+    throw new Q(`Invalid Timestamp: "${e}" does not parse as a valid date`);
+  return e;
+}
+function J() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+class W {
+  #t;
+  #i;
+  #n;
+  #e;
+  constructor(n) {
+    this.#t = n, this.#i = void 0, this.#n = /* @__PURE__ */ new Map(), this.#e = [];
+  }
+  get id() {
+    return this.#t;
+  }
+  get title() {
+    return this.#i;
+  }
+  get elements() {
+    return [...this.#n.values()];
+  }
+  // ─────────────────────────────────────────────── Factory
+  /**
+   * Creates a new List aggregate and emits ListCreated.
+   * Generates a ListId if not provided in the command.
+   */
+  static create(n) {
+    const t = n.listId ?? Qe(), i = new W(t), c = {
+      type: "ListCreated",
+      listEventId: K(),
+      listId: t,
+      actorId: n.actorId,
+      timestamp: J(),
+      ...n.title !== void 0 ? { title: n.title } : {}
+    };
+    return i.#r(c), i.#e.push(c), { list: i, event: c };
+  }
+  // ─────────────────────────────────────────────── Rehydration
+  /**
+   * Reconstructs a List from its full event log.
+   * The resulting List has no uncommitted events.
+   */
+  static rehydrate(n, t) {
+    const i = new W(n);
+    for (const c of t)
+      i.#r(c);
+    return i;
+  }
+  // ─────────────────────────────────────────────── Command Handlers
+  /**
+   * Appends a new ListElement to the List.
+   * Invariant: content must be non-empty after trimming (enforced at ListElementContent creation).
+   */
+  addListElement(n) {
+    const t = Je(), i = {
+      type: "ListElementAdded",
+      listEventId: K(),
+      listId: this.#t,
+      actorId: n.actorId,
+      timestamp: J(),
+      listElementId: t,
+      content: n.content
+    };
+    return this.#r(i), this.#e.push(i), i;
+  }
+  /**
+   * Removes a ListElement from the List by its stable identity.
+   * Invariant: the ListElementId must exist in the current elements.
+   * Throws ListElementNotFoundError if not found.
+   */
+  deleteListElement(n) {
+    const t = n.listElementId.toString();
+    if (!this.#n.has(t))
+      throw new ke(t);
+    const i = {
+      type: "ListElementDeleted",
+      listEventId: K(),
+      listId: this.#t,
+      actorId: n.actorId,
+      timestamp: J(),
+      listElementId: n.listElementId
+    };
+    return this.#r(i), this.#e.push(i), i;
+  }
+  /**
+   * Emits a ListExported audit event.
+   * Export is always valid — no invariants to check.
+   */
+  exportListDocument(n) {
+    const t = {
+      type: "ListExported",
+      listEventId: K(),
+      listId: this.#t,
+      actorId: n.actorId,
+      timestamp: J(),
+      format: "json-ld"
+    };
+    return this.#r(t), this.#e.push(t), t;
+  }
+  // ─────────────────────────────────────────────── Uncommitted Events
+  /** Returns all events emitted since the last load/save. */
+  getUncommittedEvents() {
+    return [...this.#e];
+  }
+  /** Clears uncommitted events after they have been persisted. */
+  markEventsAsCommitted() {
+    this.#e.length = 0;
+  }
+  // ─────────────────────────────────────────────── Private State Mutation
+  /** Mutates state from a single event. Used by both command handlers and rehydration. */
+  #r(n) {
+    ({
+      ListCreated: (i) => {
+        this.#i = i.title;
+      },
+      ListElementAdded: (i) => {
+        this.#n.set(i.listElementId.toString(), {
+          id: i.listElementId,
+          content: i.content,
+          addedAt: i.timestamp
+        });
+      },
+      ListElementDeleted: (i) => {
+        this.#n.delete(i.listElementId.toString());
+      },
+      // Audit-only event — no state change
+      ListExported: (i) => {
+      }
+    })[n.type](n);
+  }
+}
+function Ze(e) {
+  return D.fromString(e, "act");
+}
+const be = 2e3;
+function Ye(e) {
+  const n = e.trim();
+  if (n.length === 0)
+    throw new Q("ListElementContent cannot be empty");
+  if (n.length > be)
+    throw new Q(`ListElementContent exceeds maximum length of ${be} characters`);
+  return n;
+}
+const et = {
+  "@vocab": "https://schema.org/",
+  alistigo: "https://alistigo.ai/vocab/"
+}, tt = "1.0.0";
+function nt(e) {
+  const n = {
+    "alistigo:listEventId": e.listEventId.toString(),
+    "alistigo:listId": e.listId.toString(),
+    "alistigo:actorId": e.actorId.toString(),
+    "alistigo:timestamp": e.timestamp
+  };
+  switch (e.type) {
+    case "ListCreated":
+      return {
+        ...n,
+        "alistigo:eventType": "ListCreated",
+        ...e.title !== void 0 ? { name: e.title } : {}
+      };
+    case "ListElementAdded":
+      return {
+        ...n,
+        "alistigo:eventType": "ListElementAdded",
+        "alistigo:listElementId": e.listElementId.toString(),
+        name: e.content
+      };
+    case "ListElementDeleted":
+      return {
+        ...n,
+        "alistigo:eventType": "ListElementDeleted",
+        "alistigo:listElementId": e.listElementId.toString()
+      };
+    case "ListExported":
+      return {
+        ...n,
+        "alistigo:eventType": "ListExported"
+      };
+  }
+}
+function rt(e) {
+  const n = {
+    listEventId: Xe(e["alistigo:listEventId"]),
+    listId: Oe(e["alistigo:listId"]),
+    actorId: Ze(e["alistigo:actorId"]),
+    timestamp: We(e["alistigo:timestamp"])
+  };
+  switch (e["alistigo:eventType"]) {
+    case "ListCreated": {
+      const t = e;
+      return {
+        ...n,
+        type: "ListCreated",
+        ...t.name !== void 0 ? { title: t.name } : {}
+      };
+    }
+    case "ListElementAdded": {
+      const t = e;
+      return {
+        ...n,
+        type: "ListElementAdded",
+        listElementId: pe(t["alistigo:listElementId"]),
+        content: Ye(t.name)
+      };
+    }
+    case "ListElementDeleted":
+      return {
+        ...n,
+        type: "ListElementDeleted",
+        listElementId: pe(e["alistigo:listElementId"])
+      };
+    case "ListExported":
+      return {
+        ...n,
+        type: "ListExported",
+        format: "json-ld"
+      };
+  }
+}
+const ye = {
+  serialize(e, n) {
+    const t = n?.["alistigo:listEventLog"] ?? [], i = e.getUncommittedEvents().map(nt), c = e.elements.map((_, I) => ({
+      "@type": "ListItem",
+      "alistigo:listElementId": _.id.toString(),
+      position: I + 1,
+      name: _.content
+    })), m = {
+      "@context": et,
+      "@type": "ItemList",
+      "alistigo:listId": e.id.toString(),
+      "alistigo:schemaVersion": tt,
+      itemListElement: c,
+      "alistigo:listEventLog": [...t, ...i]
+    };
+    return e.title !== void 0 && (m.name = e.title), m;
+  },
+  deserialize(e) {
+    const n = Oe(e["alistigo:listId"]), t = e["alistigo:listEventLog"].map(rt);
+    return W.rehydrate(n, t);
+  }
+};
+function it(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var F = { exports: {} }, re, Ee;
+function st() {
+  if (Ee) return re;
+  Ee = 1;
+  function e(t) {
+    try {
+      return JSON.stringify(t);
+    } catch {
+      return '"[Circular]"';
+    }
+  }
+  re = n;
+  function n(t, i, c) {
+    var m = c && c.stringify || e, _ = 1;
+    if (typeof t == "object" && t !== null) {
+      var I = i.length + _;
+      if (I === 1) return t;
+      var E = new Array(I);
+      E[0] = m(t);
+      for (var p = 1; p < I; p++)
+        E[p] = m(i[p]);
+      return E.join(" ");
+    }
+    if (typeof t != "string")
+      return t;
+    var O = i.length;
+    if (O === 0) return t;
+    for (var x = "", b = 1 - _, g = -1, z = t && t.length || 0, d = 0; d < z; ) {
+      if (t.charCodeAt(d) === 37 && d + 1 < z) {
+        switch (g = g > -1 ? g : 0, t.charCodeAt(d + 1)) {
+          case 100:
+          // 'd'
+          case 102:
+            if (b >= O || i[b] == null) break;
+            g < d && (x += t.slice(g, d)), x += Number(i[b]), g = d + 2, d++;
+            break;
+          case 105:
+            if (b >= O || i[b] == null) break;
+            g < d && (x += t.slice(g, d)), x += Math.floor(Number(i[b])), g = d + 2, d++;
+            break;
+          case 79:
+          // 'O'
+          case 111:
+          // 'o'
+          case 106:
+            if (b >= O || i[b] === void 0) break;
+            g < d && (x += t.slice(g, d));
+            var q = typeof i[b];
+            if (q === "string") {
+              x += "'" + i[b] + "'", g = d + 2, d++;
+              break;
+            }
+            if (q === "function") {
+              x += i[b].name || "<anonymous>", g = d + 2, d++;
+              break;
+            }
+            x += m(i[b]), g = d + 2, d++;
+            break;
+          case 115:
+            if (b >= O)
+              break;
+            g < d && (x += t.slice(g, d)), x += String(i[b]), g = d + 2, d++;
+            break;
+          case 37:
+            g < d && (x += t.slice(g, d)), x += "%", g = d + 2, d++, b--;
+            break;
+        }
+        ++b;
+      }
+      ++d;
+    }
+    return g === -1 ? t : (g < z && (x += t.slice(g)), x);
+  }
+  return re;
+}
+var we;
+function ot() {
+  if (we) return F.exports;
+  we = 1;
+  const e = st();
+  F.exports = O;
+  const n = Ce().console || {}, t = {
+    mapHttpRequest: N,
+    mapHttpResponse: N,
+    wrapRequestSerializer: ee,
+    wrapResponseSerializer: ee,
+    wrapErrorSerializer: ee,
+    req: N,
+    res: N,
+    err: oe,
+    errWithCause: oe
+  };
+  function i(r, o) {
+    return r === "silent" ? 1 / 0 : o.levels.values[r];
+  }
+  const c = /* @__PURE__ */ Symbol("pino.logFuncs"), m = /* @__PURE__ */ Symbol("pino.hierarchy"), _ = {
+    error: "log",
+    fatal: "error",
+    warn: "error",
+    info: "log",
+    debug: "log",
+    trace: "log"
+  };
+  function I(r, o) {
+    const l = {
+      logger: o,
+      parent: r[m]
+    };
+    o[m] = l;
+  }
+  function E(r, o, l) {
+    const u = {};
+    o.forEach((f) => {
+      u[f] = l[f] ? l[f] : n[f] || n[_[f] || "log"] || U;
+    }), r[c] = u;
+  }
+  function p(r, o) {
+    return Array.isArray(r) ? r.filter(function(u) {
+      return u !== "!stdSerializers.err";
+    }) : r === !0 ? Object.keys(o) : !1;
+  }
+  function O(r) {
+    r = r || {}, r.browser = r.browser || {};
+    const o = r.browser.transmit;
+    if (o && typeof o.send != "function")
+      throw Error("pino: transmit option must have a send function");
+    const l = r.browser.write || n;
+    r.browser.write && (r.browser.asObject = !0);
+    const u = r.serializers || {}, f = p(r.browser.serialize, u);
+    let L = r.browser.serialize;
+    Array.isArray(r.browser.serialize) && r.browser.serialize.indexOf("!stdSerializers.err") > -1 && (L = !1);
+    const j = Object.keys(r.customLevels || {}), v = ["error", "fatal", "warn", "info", "debug", "trace"].concat(j);
+    typeof l == "function" && v.forEach(function(T) {
+      l[T] = l;
+    }), (r.enabled === !1 || r.browser.disabled) && (r.level = "silent");
+    const S = r.level || "info", a = Object.create(l);
+    a.log || (a.log = U), E(a, v, l), I({}, a), Object.defineProperty(a, "levelVal", {
+      get: C
+    }), Object.defineProperty(a, "level", {
+      get: te,
+      set: M
+    });
+    const y = {
+      transmit: o,
+      serialize: f,
+      asObject: r.browser.asObject,
+      asObjectBindingsOnly: r.browser.asObjectBindingsOnly,
+      formatters: r.browser.formatters,
+      levels: v,
+      timestamp: _e(r),
+      messageKey: r.messageKey || "msg",
+      onChild: r.onChild || U
+    };
+    a.levels = x(r), a.level = S, a.isLevelEnabled = function(T) {
+      return this.levels.values[T] ? this.levels.values[T] >= this.levels.values[this.level] : !1;
+    }, a.setMaxListeners = a.getMaxListeners = a.emit = a.addListener = a.on = a.prependListener = a.once = a.prependOnceListener = a.removeListener = a.removeAllListeners = a.listeners = a.listenerCount = a.eventNames = a.write = a.flush = U, a.serializers = u, a._serialize = f, a._stdErrSerialize = L, a.child = function(...T) {
+      return ce.call(this, y, ...T);
+    }, o && (a._logEvent = Y());
+    function C() {
+      return i(this.level, this);
+    }
+    function te() {
+      return this._level;
+    }
+    function M(T) {
+      if (T !== "silent" && !this.levels.values[T])
+        throw Error("unknown level " + T);
+      this._level = T, z(this, y, a, "error"), z(this, y, a, "fatal"), z(this, y, a, "warn"), z(this, y, a, "info"), z(this, y, a, "debug"), z(this, y, a, "trace"), j.forEach((k) => {
+        z(this, y, a, k);
+      });
+    }
+    function ce(T, k, P) {
+      if (!k)
+        throw new Error("missing bindings for child Pino");
+      P = P || {}, f && k.serializers && (P.serializers = k.serializers);
+      const ue = P.serializers;
+      if (f && ue) {
+        var B = Object.assign({}, u, ue), fe = r.browser.serialize === !0 ? Object.keys(B) : f;
+        delete k.serializers, Z([k], fe, B, this._stdErrSerialize);
+      }
+      function de(H) {
+        this._childLevel = (H._childLevel | 0) + 1, this.bindings = k, B && (this.serializers = B, this._serialize = fe), o && (this._logEvent = Y(
+          [].concat(H._logEvent.bindings, k)
+        ));
+      }
+      de.prototype = this;
+      const $ = new de(this);
+      return I(this, $), $.child = function(...H) {
+        return ce.call(this, T, ...H);
+      }, $.level = P.level || this.level, T.onChild($), $;
+    }
+    return a;
+  }
+  function x(r) {
+    const o = r.customLevels || {}, l = Object.assign({}, O.levels.values, o), u = Object.assign({}, O.levels.labels, b(o));
+    return {
+      values: l,
+      labels: u
+    };
+  }
+  function b(r) {
+    const o = {};
+    return Object.keys(r).forEach(function(l) {
+      o[r[l]] = l;
+    }), o;
+  }
+  O.levels = {
+    values: {
+      fatal: 60,
+      error: 50,
+      warn: 40,
+      info: 30,
+      debug: 20,
+      trace: 10
+    },
+    labels: {
+      10: "trace",
+      20: "debug",
+      30: "info",
+      40: "warn",
+      50: "error",
+      60: "fatal"
+    }
+  }, O.stdSerializers = t, O.stdTimeFunctions = Object.assign({}, { nullTime: ae, epochTime: le, unixTime: ze, isoTime: Ae });
+  function g(r) {
+    const o = [];
+    r.bindings && o.push(r.bindings);
+    let l = r[m];
+    for (; l.parent; )
+      l = l.parent, l.logger.bindings && o.push(l.logger.bindings);
+    return o.reverse();
+  }
+  function z(r, o, l, u) {
+    if (Object.defineProperty(r, u, {
+      value: i(r.level, l) > i(u, l) ? U : l[c][u],
+      writable: !0,
+      enumerable: !0,
+      configurable: !0
+    }), r[u] === U) {
+      if (!o.transmit) return;
+      const L = o.transmit.level || r.level, j = i(L, l);
+      if (i(u, l) < j) return;
+    }
+    r[u] = q(r, o, l, u);
+    const f = g(r);
+    f.length !== 0 && (r[u] = d(f, r[u]));
+  }
+  function d(r, o) {
+    return function() {
+      return o.apply(this, [...r, ...arguments]);
+    };
+  }
+  function q(r, o, l, u) {
+    return /* @__PURE__ */ (function(f) {
+      return function() {
+        const j = o.timestamp(), v = new Array(arguments.length), S = Object.getPrototypeOf && Object.getPrototypeOf(this) === n ? n : this;
+        for (var a = 0; a < v.length; a++) v[a] = arguments[a];
+        var y = !1;
+        if (o.serialize && (Z(v, this._serialize, this.serializers, this._stdErrSerialize), y = !0), o.asObject || o.formatters ? f.call(S, ...Te(this, u, v, j, o)) : f.apply(S, v), o.transmit) {
+          const C = o.transmit.level || r._level, te = i(C, l), M = i(u, l);
+          if (M < te) return;
+          je(this, {
+            ts: j,
+            methodLevel: u,
+            methodValue: M,
+            transmitValue: l.levels.values[o.transmit.level || r._level],
+            send: o.transmit.send,
+            val: i(r._level, l)
+          }, v, y);
+        }
+      };
+    })(r[c][u]);
+  }
+  function Te(r, o, l, u, f) {
+    const {
+      level: L,
+      log: j = (C) => C
+    } = f.formatters || {}, v = l.slice();
+    let S = v[0];
+    const a = {};
+    let y = (r._childLevel | 0) + 1;
+    if (y < 1 && (y = 1), u && (a.time = u), L) {
+      const C = L(o, r.levels.values[o]);
+      Object.assign(a, C);
+    } else
+      a.level = r.levels.values[o];
+    if (f.asObjectBindingsOnly) {
+      if (S !== null && typeof S == "object")
+        for (; y-- && typeof v[0] == "object"; )
+          Object.assign(a, v.shift());
+      return [j(a), ...v];
+    } else {
+      if (S !== null && typeof S == "object") {
+        for (; y-- && typeof v[0] == "object"; )
+          Object.assign(a, v.shift());
+        S = v.length ? e(v.shift(), v) : void 0;
+      } else typeof S == "string" && (S = e(v.shift(), v));
+      return S !== void 0 && (a[f.messageKey] = S), [j(a)];
+    }
+  }
+  function Z(r, o, l, u) {
+    for (const f in r)
+      if (u && r[f] instanceof Error)
+        r[f] = O.stdSerializers.err(r[f]);
+      else if (typeof r[f] == "object" && !Array.isArray(r[f]) && o)
+        for (const L in r[f])
+          o.indexOf(L) > -1 && L in l && (r[f][L] = l[L](r[f][L]));
+  }
+  function je(r, o, l, u = !1) {
+    const f = o.send, L = o.ts, j = o.methodLevel, v = o.methodValue, S = o.val, a = r._logEvent.bindings;
+    u || Z(
+      l,
+      r._serialize || Object.keys(r.serializers),
+      r.serializers,
+      r._stdErrSerialize === void 0 ? !0 : r._stdErrSerialize
+    ), r._logEvent.ts = L, r._logEvent.messages = l.filter(function(y) {
+      return a.indexOf(y) === -1;
+    }), r._logEvent.level.label = j, r._logEvent.level.value = v, f(j, r._logEvent, S), r._logEvent = Y(a);
+  }
+  function Y(r) {
+    return {
+      ts: 0,
+      messages: [],
+      bindings: r || [],
+      level: { label: "", value: 0 }
+    };
+  }
+  function oe(r) {
+    const o = {
+      type: r.constructor.name,
+      msg: r.message,
+      stack: r.stack
+    };
+    for (const l in r)
+      o[l] === void 0 && (o[l] = r[l]);
+    return o;
+  }
+  function _e(r) {
+    return typeof r.timestamp == "function" ? r.timestamp : r.timestamp === !1 ? ae : le;
+  }
+  function N() {
+    return {};
+  }
+  function ee(r) {
+    return r;
+  }
+  function U() {
+  }
+  function ae() {
+    return !1;
+  }
+  function le() {
+    return Date.now();
+  }
+  function ze() {
+    return Math.round(Date.now() / 1e3);
+  }
+  function Ae() {
+    return new Date(Date.now()).toISOString();
+  }
+  function Ce() {
+    function r(o) {
+      return typeof o < "u" && o;
+    }
+    try {
+      return typeof globalThis < "u" || Object.defineProperty(Object.prototype, "globalThis", {
+        get: function() {
+          return delete Object.prototype.globalThis, this.globalThis = this;
+        },
+        configurable: !0
+      }), globalThis;
+    } catch {
+      return r(self) || r(window) || r(this) || {};
+    }
+  }
+  return F.exports.default = O, F.exports.pino = O, F.exports;
+}
+var at = ot();
+const lt = /* @__PURE__ */ it(at), ct = lt({
+  level: "silent",
+  browser: { asObject: !0 }
+}), ut = (e, n) => ct.child({ module: e, ...n }), X = ut("alistigo:claude-storage"), ft = 1e3;
+function V(e) {
+  return Promise.race([
+    e,
+    new Promise(
+      (n, t) => setTimeout(() => t(new Error("Storage operation timed out")), ft)
+    )
+  ]);
+}
+const R = (e) => `alistigo-${e.toString()}`;
+class dt {
+  get storage() {
+    const n = window.storage;
+    if (!n)
+      throw new Error(
+        "ClaudeArtifactListRepository requires window.storage — use isClaudeArtifactContext() before instantiating"
+      );
+    return n;
+  }
+  async load(n) {
+    try {
+      X.debug({ key: R(n) }, "loading from claude storage");
+      const t = await V(this.storage.get(R(n))), i = JSON.parse(t.value);
+      return ye.deserialize(i);
+    } catch (t) {
+      X.debug({ err: t }, "load from claude storage returned nothing (key may not exist)");
+      return;
+    }
+  }
+  async save(n) {
+    const t = await this.loadDocument(n.id), i = ye.serialize(n, t);
+    await V(this.storage.set(R(n.id), JSON.stringify(i))), X.debug({ key: R(n.id) }, "saved to claude storage");
+  }
+  async loadDocument(n) {
+    try {
+      const t = await V(this.storage.get(R(n)));
+      return JSON.parse(t.value);
+    } catch (t) {
+      X.debug({ err: t }, "loadDocument from claude storage returned nothing (key may not exist)");
+      return;
+    }
+  }
+}
+function mt() {
+  return typeof window < "u" && typeof window.claude?.complete == "function";
+}
+const ht = {
+  name: "@alistigo/claude-storage-plugin",
+  type: "storage",
+  storage: {
+    isAvailable() {
+      return mt();
+    },
+    createStore() {
+      return new dt();
+    },
+    async listKeys(e = "") {
+      const n = window.storage;
+      if (!n) return [];
+      try {
+        const t = await V(n.list(e));
+        return t ? (await Promise.all(
+          t.keys.map(async (c) => {
+            try {
+              const m = await V(n.get(c));
+              return { key: c, value: m.value };
+            } catch {
+              return null;
+            }
+          })
+        )).filter((c) => c !== null) : [];
+      } catch {
+        return [];
+      }
+    }
+  }
+};
+export {
+  dt as ClaudeArtifactListRepository,
+  ht as default,
+  mt as isClaudeArtifactContext
+};
+//# sourceMappingURL=index.js.map