@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0

package/dist/chunk-2WTYE4SW.js

@@ -0,0 +1,190 @@
+// ../../lib/terminals-tech/core/base/events.ts
+function createEventBus() {
+  const handlers = /* @__PURE__ */ new Map();
+  const wildcardHandlers = /* @__PURE__ */ new Set();
+  function getHandlers(event) {
+    if (!handlers.has(event)) {
+      handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    return handlers.get(event);
+  }
+  return {
+    on(event, handler) {
+      const set = getHandlers(event);
+      set.add(handler);
+      return () => set.delete(handler);
+    },
+    once(event, handler) {
+      const set = getHandlers(event);
+      const wrapper = (payload) => {
+        set.delete(wrapper);
+        handler(payload);
+      };
+      set.add(wrapper);
+      return () => set.delete(wrapper);
+    },
+    off(event, handler) {
+      const set = handlers.get(event);
+      if (set) {
+        set.delete(handler);
+      }
+    },
+    emit(event, payload) {
+      const set = handlers.get(event);
+      if (set) {
+        for (const handler of set) {
+          try {
+            handler(payload);
+          } catch (e) {
+            console.error(`EventBus: Error in handler for '${String(event)}'`, e);
+          }
+        }
+      }
+      for (const handler of wildcardHandlers) {
+        try {
+          handler(event, payload);
+        } catch (e) {
+          console.error(`EventBus: Error in wildcard handler for '${String(event)}'`, e);
+        }
+      }
+    },
+    async emitAsync(event, payload) {
+      const set = handlers.get(event);
+      const promises = [];
+      if (set) {
+        for (const handler of set) {
+          promises.push(
+            Promise.resolve().then(() => handler(payload)).catch((e) => {
+              console.error(`EventBus: Error in async handler for '${String(event)}'`, e);
+            })
+          );
+        }
+      }
+      for (const handler of wildcardHandlers) {
+        promises.push(
+          Promise.resolve().then(() => handler(event, payload)).catch((e) => {
+            console.error(`EventBus: Error in async wildcard handler for '${String(event)}'`, e);
+          })
+        );
+      }
+      await Promise.all(promises);
+    },
+    onAny(handler) {
+      wildcardHandlers.add(handler);
+      return () => wildcardHandlers.delete(handler);
+    },
+    removeAllListeners(event) {
+      if (event !== void 0) {
+        handlers.delete(event);
+      } else {
+        handlers.clear();
+        wildcardHandlers.clear();
+      }
+    },
+    listenerCount(event) {
+      return handlers.get(event)?.size ?? 0;
+    },
+    eventNames() {
+      return Array.from(handlers.keys());
+    }
+  };
+}
+function createSignalBus(maxLogSize = 1e3) {
+  const subscriptions = [];
+  const signalLog = [];
+  let idCounter = 0;
+  function matches(sub, signal) {
+    if (sub.type !== "*" && sub.type !== signal.type) {
+      return false;
+    }
+    if (sub.sourceLayer && sub.sourceLayer !== signal.source) {
+      return false;
+    }
+    if (sub.targetLayer && sub.targetLayer !== signal.target) {
+      return false;
+    }
+    return true;
+  }
+  return {
+    emit(type, source, target, payload, correlationId, interactionId) {
+      const signal = {
+        id: `sig_${++idCounter}_${Date.now()}`,
+        type,
+        source,
+        target,
+        payload,
+        timestamp: Date.now(),
+        correlationId,
+        interactionId
+      };
+      signalLog.push(signal);
+      if (signalLog.length > maxLogSize) {
+        signalLog.shift();
+      }
+      for (const sub of subscriptions) {
+        if (matches(sub, signal)) {
+          try {
+            sub.handler(signal);
+          } catch (error) {
+            console.error(`[SignalBus] Handler error for ${type}:`, error);
+          }
+        }
+      }
+      return signal;
+    },
+    subscribe(type, handler, options) {
+      const subscription = {
+        type,
+        handler,
+        sourceLayer: options?.sourceLayer,
+        targetLayer: options?.targetLayer
+      };
+      subscriptions.push(subscription);
+      return () => {
+        const index = subscriptions.indexOf(subscription);
+        if (index >= 0) {
+          subscriptions.splice(index, 1);
+        }
+      };
+    },
+    subscribeFromLayer(layer, handler) {
+      return this.subscribe("*", handler, { sourceLayer: layer });
+    },
+    subscribeToLayer(layer, handler) {
+      return this.subscribe("*", handler, { targetLayer: layer });
+    },
+    getRecentSignals(count = 10) {
+      return signalLog.slice(-count);
+    },
+    getCorrelated(correlationId) {
+      return signalLog.filter((s) => s.correlationId === correlationId);
+    },
+    clearSubscriptions() {
+      subscriptions.length = 0;
+    },
+    clearLog() {
+      signalLog.length = 0;
+    }
+  };
+}
+var globalSignalBus = null;
+function getSignalBus() {
+  if (!globalSignalBus) {
+    globalSignalBus = createSignalBus();
+  }
+  return globalSignalBus;
+}
+function emitSignal(type, source, target, payload, correlationId, interactionId) {
+  return getSignalBus().emit(type, source, target, payload, correlationId, interactionId);
+}
+function subscribeToSignals(type, handler, options) {
+  return getSignalBus().subscribe(type, handler, options);
+}
+
+export {
+  createEventBus,
+  createSignalBus,
+  getSignalBus,
+  emitSignal,
+  subscribeToSignals
+};

package/dist/chunk-3LFMIVJM.js

@@ -0,0 +1,40 @@
+// ../../lib/pglite/storage.ts
+async function getStorageEstimate() {
+  if (typeof navigator === "undefined" || !navigator.storage?.estimate) return null;
+  return navigator.storage.estimate();
+}
+async function isStoragePersisted() {
+  if (typeof navigator === "undefined" || !navigator.storage?.persisted) return null;
+  return navigator.storage.persisted();
+}
+async function requestPersistentStorage() {
+  if (typeof navigator === "undefined" || !navigator.storage?.persist) return null;
+  return navigator.storage.persist();
+}
+function dataDirToDbName(dataDir) {
+  if (!dataDir.startsWith("idb://")) return null;
+  const name = dataDir.slice("idb://".length);
+  return name || null;
+}
+async function deleteDatabaseByDataDir(dataDir) {
+  const name = dataDirToDbName(dataDir);
+  if (!name) {
+    throw new Error(`Unsupported dataDir: ${dataDir}`);
+  }
+  if (typeof indexedDB === "undefined") {
+    throw new Error("indexedDB is not available in this environment");
+  }
+  await new Promise((resolve, reject) => {
+    const request = indexedDB.deleteDatabase(name);
+    request.onsuccess = () => resolve();
+    request.onerror = () => reject(request.error ?? new Error("Failed to delete IndexedDB"));
+    request.onblocked = () => reject(new Error("Delete blocked by open connections"));
+  });
+}
+
+export {
+  getStorageEstimate,
+  isStoragePersisted,
+  requestPersistentStorage,
+  deleteDatabaseByDataDir
+};

package/dist/chunk-ABCK4FWN.js

@@ -0,0 +1,136 @@
+// ../../lib/skills/types.ts
+var SKILL_CATEGORIES = [
+  "startup",
+  "legal",
+  "finance",
+  "engineering",
+  "content",
+  "research",
+  "operations",
+  "marketing",
+  "verification"
+];
+var SKILL_TIERS = ["flagship", "professional", "utility"];
+var SKILL_RANKS = ["skill", "flow", "fleet", "org", "society"];
+var SKILL_RUN_STATUSES = [
+  "pending",
+  "running",
+  "gate_pending",
+  "paused",
+  "resuming",
+  "retrying",
+  "completed",
+  "failed",
+  "cancelled"
+];
+function isSkillCategory(value) {
+  return typeof value === "string" && SKILL_CATEGORIES.includes(value);
+}
+function isSkillTier(value) {
+  return typeof value === "string" && SKILL_TIERS.includes(value);
+}
+function isSkillManifest(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value;
+  if (!Array.isArray(obj.nodes)) return false;
+  if (typeof obj.skill !== "object" || obj.skill === null) return false;
+  const skill = obj.skill;
+  return typeof skill.slug === "string" && typeof skill.title === "string" && isSkillCategory(skill.category) && isSkillTier(skill.tier);
+}
+
+// ../../lib/registry.ts
+var ManifestRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  register(manifest, type, source, tags) {
+    const key = this.deriveKey(manifest, type);
+    if (!key) return;
+    this.entries.set(key, {
+      type,
+      manifest,
+      source,
+      registeredAt: Date.now(),
+      tags
+    });
+  }
+  get(key) {
+    return this.entries.get(key);
+  }
+  getSkill(slug) {
+    const entry = this.entries.get(slug);
+    if (entry && entry.type === "skill") {
+      return entry.manifest;
+    }
+    return void 0;
+  }
+  getAll(filter) {
+    let results = [];
+    for (const entry of this.entries.values()) {
+      if (filter?.type && entry.type !== filter.type) continue;
+      if (filter?.source && entry.source !== filter.source) continue;
+      if (filter?.category && entry.type === "skill") {
+        const skill = entry.manifest;
+        if (skill.skill.category !== filter.category) continue;
+      }
+      if (filter?.tags && filter.tags.length > 0) {
+        const entryTags = entry.tags ?? [];
+        if (!filter.tags.some((t) => entryTags.includes(t))) continue;
+      }
+      results.push(entry);
+    }
+    results.sort((a, b) => b.registeredAt - a.registeredAt);
+    if (filter?.limit && filter.limit > 0) {
+      results = results.slice(0, filter.limit);
+    }
+    return results;
+  }
+  resolve(ref) {
+    const colonIdx = ref.indexOf(":");
+    if (colonIdx > 0) {
+      const key = ref.slice(colonIdx + 1);
+      return this.entries.get(key) ?? null;
+    }
+    return this.entries.get(ref) ?? null;
+  }
+  search(query, filter) {
+    const q = query.toLowerCase();
+    const all = this.getAll(filter);
+    return all.filter((entry) => {
+      const m = entry.manifest;
+      if (m.name?.toLowerCase().includes(q)) return true;
+      if (m.description?.toLowerCase().includes(q)) return true;
+      if (m.id?.toLowerCase().includes(q)) return true;
+      if (entry.type === "skill") {
+        const skill = m;
+        if (skill.skill.slug.toLowerCase().includes(q)) return true;
+        if (skill.skill.title.toLowerCase().includes(q)) return true;
+        if (skill.skill.tags.some((t) => t.toLowerCase().includes(q))) return true;
+      }
+      return false;
+    });
+  }
+  unregister(key) {
+    return this.entries.delete(key);
+  }
+  get size() {
+    return this.entries.size;
+  }
+  clear() {
+    this.entries.clear();
+  }
+  deriveKey(manifest, type) {
+    if (type === "skill" && isSkillManifest(manifest)) {
+      return manifest.skill.slug;
+    }
+    return manifest.id;
+  }
+};
+var registry = new ManifestRegistry();
+
+export {
+  SKILL_CATEGORIES,
+  SKILL_TIERS,
+  SKILL_RANKS,
+  SKILL_RUN_STATUSES,
+  ManifestRegistry,
+  registry
+};