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

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-3CEM77QZ.js

@@ -0,0 +1,474 @@
+// ../../lib/terminals-tech/machines/core/catalog.ts
+var inMemoryCatalog = /* @__PURE__ */ new Map();
+var nodesInitialized = false;
+async function ensureNodesLoaded() {
+  if (!nodesInitialized) {
+    await import("./nodes-DXKYDTVO.js");
+    nodesInitialized = true;
+  }
+}
+var manifestProviders = /* @__PURE__ */ new Map();
+function registerNode(manifest) {
+  inMemoryCatalog.set(manifest.id, manifest);
+}
+function registerManifestProvider(name, provider) {
+  manifestProviders.set(name, provider);
+}
+async function resolveNode(ref) {
+  await ensureNodesLoaded();
+  const staticNode = inMemoryCatalog.get(ref);
+  if (staticNode) return staticNode;
+  for (const provider of manifestProviders.values()) {
+    try {
+      const manifest = await provider(ref);
+      if (manifest) return manifest;
+    } catch (err) {
+      console.warn(`[resolveNode] Provider failed for ${ref}:`, err);
+    }
+  }
+  return null;
+}
+registerNode({
+  id: "demo.echo.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Echo",
+  description: "Returns input as output",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { message: { type: "string" } },
+    required: ["message"]
+  },
+  outputsSchema: { type: "object", properties: { echoed: { type: "object" } } }
+});
+registerNode({
+  id: "demo.webhook.post.v1",
+  version: "0.1.0",
+  kind: "webhook",
+  label: "Webhook POST",
+  description: "POST JSON to a URL",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { url: { type: "string" }, body: { type: "object" } },
+    required: ["url", "body"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: {
+      status: { type: "number" },
+      ok: { type: "boolean" },
+      body: { type: "string" }
+    }
+  },
+  policies: {
+    network: { egress: "allow:list", allowList: ["https://httpbin.org"] }
+  },
+  secrets: [
+    {
+      name: "DEMO_BEARER_TOKEN",
+      scope: "node",
+      env: "AUTH_TOKEN",
+      required: false
+    }
+  ]
+});
+registerNode({
+  id: "demo.mcp.echo.v1",
+  version: "0.1.0",
+  kind: "mcp",
+  label: "MCP Echo",
+  description: "Demonstrates MCP policy gate and echo",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { service: { type: "string" }, model: { type: "string" } },
+    required: ["service", "model"]
+  },
+  outputsSchema: { type: "object" },
+  mcp: { server: "https://example.com/mcp", tools: [] }
+});
+registerNode({
+  id: "demo.webcontainer.echo.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "WC Echo",
+  description: "Runs a trivial command in WebContainer and echoes inputs",
+  runtimes: ["webcontainer"],
+  entrypoints: {
+    webcontainer: { command: "node", args: ["-e", 'console.log("wc-node")'] }
+  },
+  inputsSchema: {
+    type: "object",
+    properties: { payload: { type: "object" } },
+    required: ["payload"]
+  },
+  outputsSchema: { type: "object" }
+});
+registerNode({
+  id: "system.input.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Stack Input",
+  description: "Defines the inputs for a stack.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: { type: "object" },
+  outputsSchema: { type: "object" }
+});
+registerNode({
+  id: "system.output.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Stack Output",
+  description: "Defines the outputs of a stack.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: { type: "object" },
+  outputsSchema: { type: "object" }
+});
+registerNode({
+  id: "base.time.timeline.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Timeline",
+  description: "Event clock, windows and scheduling for temporal flows.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { events: { type: "array" }, window: { type: "string" } }
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { windowEvents: { type: "array" }, ticks: { type: "array" } }
+  }
+});
+registerNode({
+  id: "base.time.memory.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Temporal Memory",
+  description: "Time-indexed key-value store with TTL and query windows.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { put: { type: "object" }, get: { type: "object" } }
+  },
+  outputsSchema: { type: "object" }
+});
+registerNode({
+  id: "base.field.store3d.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Field Store 3D",
+  description: "Stores/queries radiance, SDF, or gaussian splat parameters.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { upsert: { type: "array" }, query: { type: "object" } }
+  },
+  outputsSchema: { type: "object" },
+  capabilities: ["fields:xyzt"]
+});
+registerNode({
+  id: "base.field.projector.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Cross\u2011Modal Projector",
+  description: "Maps field points (xyzt) to semantic embeddings/entities.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { points: { type: "array" }, model: { type: "string" } }
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { embeddings: { type: "array" } }
+  }
+});
+registerNode({
+  id: "base.semantic.zero-agent.v1",
+  version: "0.1.0",
+  kind: "prompt",
+  label: "Zero Agent",
+  description: "LLM tool-using node with context shaping and routing.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      prompt: { type: "string" },
+      tools: { type: "array" },
+      memory: { type: "object" }
+    }
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { messages: { type: "array" }, artifacts: { type: "array" } }
+  }
+});
+registerNode({
+  id: "base.semantic.entity-graph.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Entity Graph",
+  description: "Typed nodes/edges with uncertainty; updates by deltas.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { upsert: { type: "array" }, query: { type: "object" } }
+  },
+  outputsSchema: { type: "object" }
+});
+registerNode({
+  id: "base.interface.oracle-adapter.v1",
+  version: "0.1.0",
+  kind: "webhook",
+  label: "Oracle Adapter",
+  description: "Bridges external web apps/APIs into the composition.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: { type: "object", properties: { request: { type: "object" } } },
+  outputsSchema: {
+    type: "object",
+    properties: { response: { type: "object" } }
+  },
+  policies: { network: { egress: "ask" } }
+});
+registerNode({
+  id: "astro.transform.buildAgentPrompt.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Build Agent Prompt",
+  description: "Constructs an astronomer assistant prompt from a user question and product/record context.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      question: { type: "string" },
+      product: { type: "object" },
+      record: { type: "object" }
+    },
+    required: ["question"]
+  },
+  outputsSchema: { type: "object", properties: { prompt: { type: "string" } } }
+});
+registerNode({
+  id: "transform.object.pickPath.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Pick Path",
+  description: "Extracts a nested value from an object using a dot path.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { object: { type: "object" }, path: { type: "string" } },
+    required: ["object", "path"]
+  },
+  outputsSchema: { type: "object", properties: { value: { type: "object" } } }
+});
+registerNode({
+  id: "intel.llm.http.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "HTTP LLM (OpenRouter)",
+  description: "Calls an LLM provider over HTTP (default OpenRouter). Inputs: prompt, model, apiKey.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      prompt: { type: "string" },
+      model: { type: "string" },
+      apiKey: { type: "string" }
+    },
+    required: ["prompt"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { text: { type: "string" }, messages: { type: "array" } }
+  },
+  policies: {
+    network: { egress: "allow:list", allowList: ["https://openrouter.ai"] }
+  }
+});
+registerNode({
+  id: "provider.http.invoke.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "HTTP Invoke",
+  description: "Calls an HTTP endpoint with method/headers/body; returns JSON or text.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string" },
+      method: { type: "string" },
+      headers: { type: "object" },
+      body: { type: "object" },
+      parse: { type: "string" }
+    },
+    required: ["url"]
+  },
+  outputsSchema: { type: "object" },
+  policies: { network: { egress: "ask" } }
+});
+registerNode({
+  id: "provider.tap.query.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "TAP Query",
+  description: "Executes ADQL via TAP sync endpoint and returns rows as JSON.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      tapUrl: { type: "string" },
+      adql: { type: "string" },
+      format: { type: "string" },
+      maxRows: { type: "number" },
+      token: { type: "string" }
+    },
+    required: ["tapUrl", "adql"]
+  },
+  outputsSchema: { type: "object" },
+  policies: { network: { egress: "ask" } }
+});
+registerNode({
+  id: "table.firstRow.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "First Row",
+  description: "Selects the first record from a table of rows.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { rows: { type: "array" } },
+    required: ["rows"]
+  },
+  outputsSchema: { type: "object", properties: { record: { type: "object" } } }
+});
+registerNode({
+  id: "items.pickPreferred.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Pick Preferred Items",
+  description: "Picks preferred items by ordered type keys; returns selected array.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      items: { type: "array" },
+      prefer: { type: "array" },
+      typeKey: { type: "string" },
+      groupKey: { type: "string" }
+    },
+    required: ["items"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { selected: { type: "array" } }
+  }
+});
+registerNode({
+  id: "transform.buildPrompt.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Build Prompt",
+  description: "Constructs an assistant prompt from question + context (record or object).",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { question: { type: "string" }, context: { type: "object" } },
+    required: ["question"]
+  },
+  outputsSchema: { type: "object", properties: { prompt: { type: "string" } } }
+});
+registerNode({
+  id: "intel.embedText.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Embed Text",
+  description: "Computes an embedding vector from text.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { text: { type: "string" } },
+    required: ["text"]
+  },
+  outputsSchema: { type: "object", properties: { vector: { type: "array" } } }
+});
+registerNode({
+  id: "integration.source.poll.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Integration Source (Poll)",
+  description: "Polls a provider resource with cursoring and returns normalized events.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      provider: { type: "string" },
+      resource: { type: "string" },
+      config: { type: "object" },
+      cursorKey: { type: "string" }
+    },
+    required: ["provider", "resource"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { items: { type: "array" }, cursor: { type: "string" } }
+  },
+  policies: { network: { egress: "ask" } },
+  secrets: [{ name: "DISCORD_BOT_TOKEN", scope: "stack", required: false }]
+});
+registerNode({
+  id: "integration.sink.post.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Integration Sink (Post)",
+  description: "Posts items to a provider resource (supports webhooks or REST).",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      provider: { type: "string" },
+      resource: { type: "string" },
+      config: { type: "object" },
+      item: { type: "object" },
+      items: { type: "array" }
+    },
+    required: ["provider", "resource"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { ok: { type: "boolean" }, status: { type: "number" } }
+  },
+  policies: { network: { egress: "ask" } },
+  secrets: [{ name: "DISCORD_BOT_TOKEN", scope: "stack", required: false }]
+});
+
+export {
+  registerNode,
+  registerManifestProvider,
+  resolveNode
+};

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
+};