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

package/dist/chunk-PWAHFID5.js

@@ -0,0 +1,381 @@
+import {
+  appendMeshEvent
+} from "./chunk-Y2EULKA2.js";
+import {
+  createAddress,
+  createInteractionWithEvents,
+  sanitizeTraceSegment,
+  transitionStatusWithEvent
+} from "./chunk-BCOQMFKT.js";
+import {
+  secureValidate
+} from "./chunk-FOXUEYWK.js";
+import {
+  DEFAULT_EMBEDDING_DIM
+} from "./chunk-ZVO47SQV.js";
+import {
+  isDatabaseReady
+} from "./chunk-AFDUOYHD.js";
+
+// ../../lib/terminals-tech/mesh/events.ts
+var logs = /* @__PURE__ */ new Map();
+function createEventLog(id) {
+  const log = {
+    id: id || crypto.randomUUID(),
+    events: [],
+    createdAt: Date.now()
+  };
+  logs.set(log.id, log);
+  return log;
+}
+function appendEvent(logId, type, payload, embedding, metadata) {
+  let log = logs.get(logId);
+  if (!log) {
+    log = createEventLog(logId);
+  }
+  const event = {
+    id: crypto.randomUUID(),
+    type,
+    payload,
+    timestamp: Date.now(),
+    embedding,
+    metadata
+  };
+  log.events = [...log.events, event];
+  log.lastEventAt = event.timestamp;
+  return event;
+}
+function queryEvents(logId, query = {}) {
+  const log = logs.get(logId);
+  if (!log) return [];
+  let events = log.events;
+  if (query.types && query.types.length > 0) {
+    const types = query.types;
+    events = events.filter((e) => types.includes(e.type));
+  }
+  if (query.since !== void 0) {
+    const since = query.since;
+    events = events.filter((e) => e.timestamp >= since);
+  }
+  if (query.until !== void 0) {
+    const until = query.until;
+    events = events.filter((e) => e.timestamp <= until);
+  }
+  if (query.withEmbedding === false) {
+    events = events.filter((e) => !e.embedding);
+  } else if (query.withEmbedding === true) {
+    events = events.filter((e) => !!e.embedding);
+  }
+  if (query.interactionId !== void 0) {
+    const interactionId = query.interactionId;
+    events = events.filter((e) => e.metadata?.interactionId === interactionId);
+  }
+  if (query.limit) {
+    events = events.slice(-query.limit);
+  }
+  return events;
+}
+function queryByInteraction(logId, interactionId, additionalQuery = {}) {
+  return queryEvents(logId, {
+    ...additionalQuery,
+    interactionId
+  });
+}
+
+// ../../lib/terminals-tech/mesh/interaction-store.ts
+var INTERACTION_LOG_ID = "mesh-interactions";
+var runToInteraction = /* @__PURE__ */ new Map();
+var interactionSequences = /* @__PURE__ */ new Map();
+var INTERACTION_CREATED_PAYLOAD_SCHEMA = {
+  type: "object",
+  required: ["interaction"],
+  properties: {
+    interaction: { type: "object" },
+    sequence: { type: "number" }
+  },
+  additionalProperties: true
+};
+var INTERACTION_STATUS_PAYLOAD_SCHEMA = {
+  type: "object",
+  required: ["interactionId", "to", "at"],
+  properties: {
+    interactionId: { type: "string" },
+    from: { type: "string" },
+    to: { type: "string" },
+    at: { type: "number" },
+    sequence: { type: "number" }
+  },
+  additionalProperties: true
+};
+function getDefaultCoordinator() {
+  return createAddress("L2", "orchestrator", "v0");
+}
+function nextSequence(interactionId) {
+  const current = interactionSequences.get(interactionId) ?? 0;
+  const next = current + 1;
+  interactionSequences.set(interactionId, next);
+  return next;
+}
+function buildInteractionTracePath(interactionId, eventType) {
+  const interaction = sanitizeTraceSegment(interactionId) || "unknown";
+  const event = sanitizeTraceSegment(eventType) || "event";
+  return `interactions.${interaction}.${event}`;
+}
+function attachSequence(interactionId, payload) {
+  const current = payload.sequence;
+  const sequence = current ?? nextSequence(interactionId);
+  return { ...payload, sequence };
+}
+function getInteractionForTransition(interactionId) {
+  const events = queryByInteraction(INTERACTION_LOG_ID, interactionId);
+  if (!events.length) return null;
+  let interaction = null;
+  let latestStatusPayload = null;
+  for (const event of events) {
+    if (event.type === "interaction:created") {
+      const validated = secureValidate(event.payload, INTERACTION_CREATED_PAYLOAD_SCHEMA);
+      if (validated) {
+        const payload = validated;
+        if (payload.interaction) {
+          interaction = payload.interaction;
+        }
+      }
+    }
+    if (event.type === "interaction:status_changed") {
+      const validated = secureValidate(event.payload, INTERACTION_STATUS_PAYLOAD_SCHEMA);
+      if (validated) {
+        latestStatusPayload = validated;
+      }
+    }
+  }
+  if (!interaction) return null;
+  if (latestStatusPayload) {
+    interaction = {
+      ...interaction,
+      status: latestStatusPayload.to,
+      startedAt: latestStatusPayload.to === "active" ? latestStatusPayload.at : interaction.startedAt,
+      completedAt: ["completed", "failed", "cancelled"].includes(latestStatusPayload.to) ? latestStatusPayload.at : interaction.completedAt
+    };
+  }
+  return interaction;
+}
+async function emitInteractionEvent(interactionId, type, payload, metadata) {
+  const payloadWithSequence = attachSequence(interactionId, payload);
+  const result = await appendMeshSinkEvent({
+    tracePath: buildInteractionTracePath(interactionId, type),
+    payload: payloadWithSequence,
+    metadata,
+    logId: INTERACTION_LOG_ID,
+    typeOverride: type
+  });
+  if (result.mode === "pglite") {
+    appendEvent(INTERACTION_LOG_ID, type, payloadWithSequence, void 0, metadata);
+  }
+  const enrichedMeta = metadata ?? {};
+  const userId = enrichedMeta.userId ?? enrichedMeta.user_id;
+  if (userId && typeof window !== "undefined") {
+    try {
+      const { appendSupabaseMeshEvent } = await import("./supabaseService-6AYP2VY3.js");
+      await appendSupabaseMeshEvent({
+        user_id: userId,
+        interaction_id: interactionId,
+        run_id: enrichedMeta.runId || null,
+        stack_id: enrichedMeta.stackId || null,
+        prev_hash: null,
+        trace_path: buildInteractionTracePath(interactionId, type),
+        type,
+        payload: payloadWithSequence,
+        metadata: enrichedMeta,
+        embedding: null,
+        span: null
+      });
+    } catch {
+    }
+  }
+}
+function emitLifecycleEvents(events, interactionId, meta) {
+  const metadata = { interactionId, ...meta };
+  events.forEach((event) => {
+    void emitInteractionEvent(interactionId, event.type, event.payload, metadata);
+  });
+}
+function ensureInteractionForRun(runId, stackId, interactionId) {
+  const existingId = interactionId || runToInteraction.get(runId);
+  if (existingId) {
+    runToInteraction.set(runId, existingId);
+    return existingId;
+  }
+  const result = createInteractionWithEvents({
+    type: "workflow",
+    status: "initiated",
+    context: { runId, stackId },
+    labels: ["orchestrator", "run"],
+    participants: [
+      {
+        address: getDefaultCoordinator(),
+        role: "coordinator",
+        metadata: { runId, stackId }
+      }
+    ]
+  });
+  runToInteraction.set(runId, result.interaction.id);
+  emitLifecycleEvents(result.events, result.interaction.id, { runId, stackId });
+  return result.interaction.id;
+}
+function recordRunStart(event, interactionId) {
+  const ensuredId = ensureInteractionForRun(event.runId, event.stackId, interactionId);
+  void emitInteractionEvent(
+    ensuredId,
+    "interaction:run_start",
+    { ...event, interactionId: ensuredId },
+    { interactionId: ensuredId, runId: event.runId, stackId: event.stackId }
+  );
+  const existing = getInteractionForTransition(ensuredId);
+  if (!existing) return ensuredId;
+  const { event: statusEvent } = transitionStatusWithEvent(existing, "active", {
+    timestamp: event.startedAt,
+    sequence: nextSequence(ensuredId)
+  });
+  void emitInteractionEvent(
+    ensuredId,
+    statusEvent.type,
+    statusEvent.payload,
+    { interactionId: ensuredId, runId: event.runId, stackId: event.stackId }
+  );
+  return ensuredId;
+}
+function recordNodeComplete(event) {
+  const interactionId = runToInteraction.get(event.runId);
+  if (!interactionId) return void 0;
+  void emitInteractionEvent(
+    interactionId,
+    "interaction:node_complete",
+    { ...event, interactionId },
+    { interactionId, runId: event.runId, nodeId: event.nodeId }
+  );
+  return interactionId;
+}
+function recordRunComplete(event) {
+  const interactionId = runToInteraction.get(event.runId);
+  if (!interactionId) return void 0;
+  void emitInteractionEvent(
+    interactionId,
+    "interaction:run_complete",
+    { ...event, interactionId },
+    { interactionId, runId: event.runId }
+  );
+  const existing = getInteractionForTransition(interactionId);
+  if (!existing) return interactionId;
+  const targetStatus = event.success ? "completed" : "failed";
+  const { event: statusEvent } = transitionStatusWithEvent(existing, targetStatus, {
+    timestamp: event.completedAt,
+    sequence: nextSequence(interactionId)
+  });
+  void emitInteractionEvent(
+    interactionId,
+    statusEvent.type,
+    statusEvent.payload,
+    { interactionId, runId: event.runId }
+  );
+  return interactionId;
+}
+function recordSystemPause(event) {
+  const interactionId = runToInteraction.get(event.runId);
+  if (!interactionId) return void 0;
+  void emitInteractionEvent(
+    interactionId,
+    "interaction:system_pause",
+    { ...event, interactionId },
+    { interactionId, runId: event.runId }
+  );
+  const existing = getInteractionForTransition(interactionId);
+  if (!existing) return interactionId;
+  const { event: statusEvent } = transitionStatusWithEvent(existing, "paused", {
+    timestamp: event.pausedAt,
+    sequence: nextSequence(interactionId)
+  });
+  void emitInteractionEvent(
+    interactionId,
+    statusEvent.type,
+    statusEvent.payload,
+    { interactionId, runId: event.runId }
+  );
+  return interactionId;
+}
+function recordSystemResume(event) {
+  const interactionId = runToInteraction.get(event.runId);
+  if (!interactionId) return void 0;
+  void emitInteractionEvent(
+    interactionId,
+    "interaction:system_resume",
+    { ...event, interactionId },
+    { interactionId, runId: event.runId }
+  );
+  const existing = getInteractionForTransition(interactionId);
+  if (!existing) return interactionId;
+  const { event: statusEvent } = transitionStatusWithEvent(existing, "active", {
+    timestamp: event.resumedAt,
+    sequence: nextSequence(interactionId)
+  });
+  void emitInteractionEvent(
+    interactionId,
+    statusEvent.type,
+    statusEvent.payload,
+    { interactionId, runId: event.runId }
+  );
+  return interactionId;
+}
+
+// ../../lib/terminals-tech/mesh/mesh-sink.ts
+function normalizeEmbedding(embedding) {
+  if (!embedding) return void 0;
+  const arr = embedding instanceof Float32Array ? embedding : new Float32Array(embedding);
+  const target = arr.length === DEFAULT_EMBEDDING_DIM ? arr : (() => {
+    const fixed = new Float32Array(DEFAULT_EMBEDDING_DIM);
+    fixed.set(arr.subarray(0, Math.min(arr.length, DEFAULT_EMBEDDING_DIM)));
+    return fixed;
+  })();
+  for (let i = 0; i < target.length; i++) {
+    if (Number.isNaN(target[i])) target[i] = 0;
+  }
+  return target;
+}
+function deriveType(tracePath, override) {
+  if (override) return override;
+  const parts = tracePath.split(".");
+  return parts[parts.length - 1] || "event";
+}
+function deriveLogId(tracePath, fallback) {
+  if (fallback) return fallback;
+  return tracePath.replace(/[^\w]+/g, "_").slice(0, 120) || "mesh";
+}
+async function appendMeshSinkEvent(input) {
+  const { tracePath, payload, embedding, metadata, span, logId, typeOverride } = input;
+  if (isDatabaseReady()) {
+    const event2 = await appendMeshEvent(
+      tracePath,
+      payload,
+      embedding ? Array.from(normalizeEmbedding(embedding) || []) : void 0,
+      span,
+      metadata
+    );
+    return { mode: "pglite", event: event2 };
+  }
+  const event = appendEvent(
+    deriveLogId(tracePath, logId),
+    deriveType(tracePath, typeOverride),
+    payload,
+    normalizeEmbedding(embedding),
+    metadata
+  );
+  return { mode: "memory", event };
+}
+
+export {
+  appendMeshSinkEvent,
+  recordRunStart,
+  recordNodeComplete,
+  recordRunComplete,
+  recordSystemPause,
+  recordSystemResume
+};

package/dist/chunk-Q2VI6ICE.js

@@ -0,0 +1,188 @@
+import {
+  recordNodeComplete,
+  recordRunComplete,
+  recordRunStart,
+  recordSystemPause,
+  recordSystemResume
+} from "./chunk-PWAHFID5.js";
+import {
+  getSignalBus
+} from "./chunk-2WTYE4SW.js";
+
+// ../../lib/terminals-tech/mesh/axon/bridges/layer-bridge.ts
+function createLayerBridge(sourceLayer, targetLayer) {
+  const upHandlers = [];
+  const downHandlers = [];
+  return {
+    sourceLayer,
+    targetLayer,
+    sendUp(data) {
+      getSignalBus().emit("health_update", sourceLayer, targetLayer, {
+        direction: "up",
+        data
+      });
+      for (const handler of upHandlers) {
+        try {
+          handler(data);
+        } catch (error) {
+          console.error(`[Bridge ${sourceLayer}->${targetLayer}] Up handler error:`, error);
+        }
+      }
+    },
+    sendDown(data) {
+      getSignalBus().emit("health_update", targetLayer, sourceLayer, {
+        direction: "down",
+        data
+      });
+      for (const handler of downHandlers) {
+        try {
+          handler(data);
+        } catch (error) {
+          console.error(`[Bridge ${targetLayer}->${sourceLayer}] Down handler error:`, error);
+        }
+      }
+    },
+    onUp(handler) {
+      upHandlers.push(handler);
+      return () => {
+        const index = upHandlers.indexOf(handler);
+        if (index >= 0) {
+          upHandlers.splice(index, 1);
+        }
+      };
+    },
+    onDown(handler) {
+      downHandlers.push(handler);
+      return () => {
+        const index = downHandlers.indexOf(handler);
+        if (index >= 0) {
+          downHandlers.splice(index, 1);
+        }
+      };
+    }
+  };
+}
+
+// ../../lib/terminals-tech/mesh/axon/bridges/l2-l3-bridge.ts
+var l2L3Bridge = createLayerBridge(
+  "L2",
+  "L3"
+);
+var orchestratorToMesh = {
+  /**
+   * Notify mesh that a run has started
+   */
+  onRunStart(runId, stackId) {
+    const event = {
+      runId,
+      stackId,
+      startedAt: Date.now()
+    };
+    l2L3Bridge.sendUp({
+      type: "run_start",
+      event
+    });
+    recordRunStart(event);
+    getSignalBus().emit("task_complete", "L2", "L3", {
+      action: "run_start",
+      runId,
+      stackId
+    });
+  },
+  /**
+   * Notify mesh that a node has completed
+   */
+  onNodeComplete(runId, nodeId, success, durationMs) {
+    const event = {
+      runId,
+      nodeId,
+      success,
+      durationMs,
+      completedAt: Date.now()
+    };
+    l2L3Bridge.sendUp({
+      type: "node_complete",
+      event
+    });
+    recordNodeComplete(event);
+    const signalType = success ? "task_complete" : "task_failed";
+    getSignalBus().emit(signalType, "L2", "L3", {
+      runId,
+      nodeId,
+      durationMs
+    });
+  },
+  /**
+   * Notify mesh that a run has completed
+   */
+  onRunComplete(runId, success, durationMs) {
+    const event = {
+      runId,
+      success,
+      durationMs,
+      completedAt: Date.now()
+    };
+    l2L3Bridge.sendUp({
+      type: "run_complete",
+      event
+    });
+    recordRunComplete(event);
+    const signalType = success ? "task_complete" : "task_failed";
+    getSignalBus().emit(signalType, "L2", "L3", {
+      action: "run_complete",
+      runId,
+      success,
+      durationMs
+    });
+  },
+  /**
+   * Notify mesh that system is pausing due to cognitive load
+   */
+  onSystemPause(runId, reason) {
+    const event = {
+      runId,
+      reason,
+      pausedAt: Date.now()
+    };
+    l2L3Bridge.sendUp({
+      type: "system_pause",
+      event
+    });
+    recordSystemPause(event);
+    getSignalBus().emit("backpressure_warning", "L2", "L3", {
+      action: "system_pause",
+      runId,
+      reason
+    });
+  },
+  /**
+   * Notify mesh that system is resuming execution
+   */
+  onSystemResume(runId) {
+    const event = {
+      runId,
+      resumedAt: Date.now()
+    };
+    l2L3Bridge.sendUp({
+      type: "system_resume",
+      event
+    });
+    recordSystemResume(event);
+    getSignalBus().emit("task_complete", "L2", "L3", {
+      action: "system_resume",
+      runId
+    });
+  }
+};
+function onOrchestratorEvent(handler) {
+  return l2L3Bridge.onUp(handler);
+}
+function onMeshFeedback(handler) {
+  return l2L3Bridge.onDown(handler);
+}
+
+export {
+  orchestratorToMesh,
+  onOrchestratorEvent,
+  onMeshFeedback
+};