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

package/README.md

@@ -1,6 +1,6 @@
 # @terminals-tech/sdk
 
-Terminals OS SDK — publish-safe facades and primitives for building observable, coherence-aware software.
+Terminals OS SDK — observable, coherence-aware primitives for building intelligent software. Available as TypeScript (`@terminals-tech/sdk`) and Rust (`terminals-core`).
 
 ## Install
 
@@ -8,10 +8,17 @@ Terminals OS SDK — publish-safe facades and primitives for building observable
 npm install @terminals-tech/sdk
 ```
 
+## Install (Rust)
+
+```toml
+[dependencies]
+terminals-core = "0.1"
+```
+
 ## Quickstart
 
 ```typescript
-import { SDK_VERSION, Brain, L0, calculateCoherence, createAxonBus } from "@terminals-tech/sdk";
+import { SDK_VERSION, Brain, L0, createAxonBus } from "@terminals-tech/sdk";
 
 // 1. The L0 Engine: Think of a Sematon as a "smart data envelope"
 // It holds your payload but also guarantees it can be mathematically transformed.
@@ -24,7 +31,7 @@ const mySematon = L0.createSematon({
 console.log("Is my payload constructive?", mySematon.constructive); // true!
 
 // 2. The L4 Brain: Measure how aligned things are
-const metrics = calculateCoherence({
+const metrics = Brain.calculateCoherence({
   output: "Execution is observable, coherence-aware, and locally steerable.",
   groundTruth: ["Execution is observable."],
 });
@@ -32,18 +39,42 @@ const metrics = calculateCoherence({
 console.log("Coherence:", metrics.overall);
 ```
 
+## Quickstart (Rust)
+
+```rust
+use terminals_core::phase::{kuramoto_step, order_parameter, phase_locking_value, Omega};
+use terminals_core::substrate::{Sematon, witness::ConvergenceWitness, graph::PadicAddr};
+
+// 1. Phase dynamics — same math as Brain.kuramotoStep in TypeScript
+let phases = vec![0.0, 1.2, 2.6, 4.1];
+let next = kuramoto_step(&phases, &Omega::Uniform(0.0), 0.8, None, 0.1, true);
+let op = order_parameter(&next);
+println!("Kuramoto R = {:.3}, psi = {:.3}", op.r, op.psi);
+
+// 2. Sematon — same concept as L0.createSematon in TypeScript
+let witness = ConvergenceWitness { r: 0.95, entropy: 0.3, converged: true, step: 10 };
+let sem = Sematon::new(vec![1.0f32, 2.0, 3.0], witness, PadicAddr::default(), "demo");
+println!("Constructive: {}", sem.constructive);
+```
+
 ## Architecture
 
 The published package exposes a curated surface oriented around stable facades and runtime-safe primitives:
 
-| Surface    | Namespace / Export            | Coverage                                                         |
-| ---------- | ----------------------------- | ---------------------------------------------------------------- |
-| Foundation | `L0`                          | Core engine math, Sematons, and Deterministic Constructor traces |
-| Terminal   | `Terminal`                    | interaction lifecycle, surface identity, platform types          |
-| Core       | `Core`                        | result types, validation, DAG, registry, retry/event primitives  |
-| Mesh       | `Mesh`                        | signals, action bus, delegation helpers                          |
-| Brain      | `Brain`, `calculateCoherence` | coherence metrics and phase primitives                           |
-| Protocol   | `Protocol`, `createAxonBus`   | delegation helpers and the AXON protocol bridge                  |
+| Surface               | Namespace / Export | Coverage                                                                  | Rust crate                                                                   |
+| --------------------- | ------------------ | ------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
+| Foundation            | `L0`               | Core engine math, Sematons, and Deterministic Constructor traces          | `terminals_core::substrate` (Sematon, fold/unfold)                           |
+| Brain                 | `Brain`            | coherence metrics and phase primitives (`Brain.calculateCoherence`, etc.) | `terminals_core::phase` (kuramoto, PLV, order parameter)                     |
+| Core                  | `Core`             | result types, validation, DAG, registry, retry/event primitives           | `terminals_core::primitives` (Result, DAG, Registry, Validated)              |
+| Wire (Rust-only)      | —                  | —                                                                         | `terminals_core::wire` (AXON binary protocol)                                |
+| Audio (Rust-only)     | —                  | —                                                                         | `terminals_core::audio` (spectral entropy, band analysis)                    |
+| Substrate (Rust-only) | —                  | —                                                                         | `terminals_core::substrate` (ComputeAtom, ProjectionLayout, SubstrateEngine) |
+| Terminal              | `Terminal`         | interaction lifecycle, surface identity, platform types                   | —                                                                            |
+| Mesh                  | `Mesh`             | signals, action bus, delegation helpers                                   | —                                                                            |
+| Protocol              | `Protocol`         | delegation helpers and the AXON protocol bridge                           | —                                                                            |
+| Skill                 | `Skill`            | skill manifest types, registry access, signal codes                       | —                                                                            |
+| Manifold              | `Manifold`         | annihilation pipeline helpers and ordinal execution surfaces              | —                                                                            |
+| Observer              | `Observer`         | observer kernel primitives and witness-oriented runtime inspection        | —                                                                            |
 
 ## ELI5: The L0 Foundation (Sematons & Constructors)
 
@@ -55,17 +86,10 @@ Developers use `L0` primitives to make sure complex AI workflows behave predicta
 ## Usage
 
 ```typescript
-import {
-  Brain,
-  Core,
-  Mesh,
-  Protocol,
-  calculateCoherence,
-  createAxonBus,
-} from "@terminals-tech/sdk";
+import { Brain, Core, Mesh, Protocol, createAxonBus } from "@terminals-tech/sdk";
 
 const bus = createAxonBus();
-const metrics = calculateCoherence({
+const metrics = Brain.calculateCoherence({
   output: "The mesh is synchronized and the route is clear.",
   groundTruth: ["The mesh is synchronized.", "Routing remains observable."],
 });
@@ -81,6 +105,23 @@ await bus.publishSDK({
 console.log({ Core, Mesh, Protocol });
 ```
 
+## TypeScript / Rust Parity
+
+The same core math runs in both runtimes. Phase dynamics, sematonic types, DAG, registry, and validation exist in both `@terminals-tech/sdk` (TypeScript) and `terminals-core` (Rust/WASM). Higher-level orchestration (Mesh signals, Protocol delegation, Observer kernel) is TypeScript-only. Low-level substrate and wire protocol are Rust-only.
+
+| Domain               | TypeScript                 | Rust                                     | Status    |
+| -------------------- | -------------------------- | ---------------------------------------- | --------- |
+| Phase dynamics       | `Brain.*`                  | `terminals_core::phase`                  | Both      |
+| Sematon / L0         | `L0.createSematon`         | `terminals_core::substrate::Sematon`     | Both      |
+| DAG                  | `Core.createDAG`           | `terminals_core::primitives::dag`        | Both      |
+| Validation (proof)   | `Core.validated`           | `terminals_core::primitives::validation` | Both      |
+| Coherence scoring    | `Brain.calculateCoherence` | —                                        | TS only   |
+| Mesh signals         | `Mesh.*`                   | —                                        | TS only   |
+| Protocol/AXON bridge | `Protocol.*`               | —                                        | TS only   |
+| AXON wire format     | —                          | `terminals_core::wire`                   | Rust only |
+| Substrate engine     | —                          | `terminals_core::substrate`              | Rust only |
+| Audio analysis       | —                          | `terminals_core::audio`                  | Rust only |
+
 ## Local verification
 
 From the monorepo root:
@@ -103,6 +144,7 @@ npm run -w @terminals-tech/sdk pack:dry-run
 2. Run `npm run sdk:publish:check`
 3. Inspect the dry-run tarball summary
 4. Publish when ready with `npm publish --workspace @terminals-tech/sdk`
+5. For `terminals-core`: `cargo publish --manifest-path crates/terminals-core/Cargo.toml`
 
 ## License
 

package/dist/{WebContainerManager-SHXC5VKI.js → WebContainerManager-NUGGUIWB.js}

@@ -2,15 +2,15 @@ import {
   ProcessPriority,
   WebContainerManager,
   WebContainerManager_default
-} from "./chunk-SHPGIVDH.js";
+} from "./chunk-P4D4RNAV.js";
 import "./chunk-DKFJIILR.js";
 import "./chunk-KHR7ZYCX.js";
+import "./chunk-WGBCRNMB.js";
 import "./chunk-QWZRZKLZ.js";
 import "./chunk-OSSRZOGC.js";
 import "./chunk-TSQ3BGLA.js";
 import "./chunk-2WTYE4SW.js";
 import "./chunk-QJFKEQHF.js";
-import "./chunk-WGBCRNMB.js";
 import "./chunk-3LFMIVJM.js";
 import "./chunk-AFDUOYHD.js";
 import "./chunk-NTMBOESX.js";

package/dist/catalog-XA5VYWXG.js

@@ -0,0 +1,16 @@
+import {
+  getCatalog,
+  listNodes,
+  registerManifestProvider,
+  registerNode,
+  resolveNode
+} from "./chunk-WT6L6DK3.js";
+import "./chunk-XPJ63Y6T.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  getCatalog,
+  listNodes,
+  registerManifestProvider,
+  registerNode,
+  resolveNode
+};

package/dist/{chunk-PWAHFID5.js → chunk-D4MOOUDY.js}

@@ -6,10 +6,10 @@ import {
   createInteractionWithEvents,
   sanitizeTraceSegment,
   transitionStatusWithEvent
-} from "./chunk-BCOQMFKT.js";
+} from "./chunk-TO7ETE5K.js";
 import {
   secureValidate
-} from "./chunk-FOXUEYWK.js";
+} from "./chunk-GOQHOLBG.js";
 import {
   DEFAULT_EMBEDDING_DIM
 } from "./chunk-ZVO47SQV.js";
@@ -175,7 +175,7 @@ async function emitInteractionEvent(interactionId, type, payload, metadata) {
   const userId = enrichedMeta.userId ?? enrichedMeta.user_id;
   if (userId && typeof window !== "undefined") {
     try {
-      const { appendSupabaseMeshEvent } = await import("./supabaseService-6AYP2VY3.js");
+      const { appendSupabaseMeshEvent } = await import("./supabaseService-O4ZFFLZP.js");
       await appendSupabaseMeshEvent({
         user_id: userId,
         interaction_id: interactionId,

package/dist/{chunk-FOXUEYWK.js → chunk-GOQHOLBG.js}

@@ -1,10 +1,10 @@
+import {
+  require_ajv
+} from "./chunk-QJFKEQHF.js";
 import {
   untrusted,
   validate
 } from "./chunk-EXI3LJVJ.js";
-import {
-  require_ajv
-} from "./chunk-QJFKEQHF.js";
 import {
   __toESM
 } from "./chunk-2ESYSVXG.js";
@@ -37,6 +37,7 @@ function secureValidate(data, schema) {
 }
 
 export {
+  getValidator,
   validateWithSchema,
   secureValidate
 };

package/dist/{chunk-PUZ2S62E.js → chunk-ICFYWOI5.js}

@@ -1,46 +1,33 @@
+import {
+  onMeshFeedback,
+  orchestratorToMesh
+} from "./chunk-UB5OINTA.js";
 import {
   getGlobalStore
 } from "./chunk-VZA2NUH3.js";
 import {
   resolveSecretValue
 } from "./chunk-QWXPVB2L.js";
-import {
-  onMeshFeedback,
-  orchestratorToMesh
-} from "./chunk-Q2VI6ICE.js";
-import {
-  registerManifestProvider
-} from "./chunk-3CEM77QZ.js";
 import {
   safeDbOperation
 } from "./chunk-WGBCRNMB.js";
+import {
+  getValidator
+} from "./chunk-GOQHOLBG.js";
 import {
   getDB,
   isDatabaseReady,
   withDB
 } from "./chunk-AFDUOYHD.js";
 
-// ../../lib/terminals-tech/machines/core/stacksStore.ts
-var globalStore = globalThis;
-var memStacks = globalStore.__memStacks || /* @__PURE__ */ new Map();
-globalStore.__memStacks = memStacks;
-var pendingDeletes = globalStore.__pendingStackDeletes || /* @__PURE__ */ new Set();
-globalStore.__pendingStackDeletes = pendingDeletes;
-registerManifestProvider("stacksStore", loadStack);
-async function loadStack(id) {
-  const { getDB: getDB2, safeDbOperation: safeDbOperation2 } = await import("./pgliteService-IUGNNOVU.js");
-  const dbResult = await safeDbOperation2(async () => {
-    const db = await getDB2();
-    await db.query(`ALTER TABLE stacks ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP`);
-    const r = await db.query(
-      `SELECT manifest FROM stacks WHERE id = $1 AND deleted_at IS NULL`,
-      [id]
-    );
-    if (!r.rows[0]) return null;
-    return r.rows[0].manifest;
-  }, null);
-  if (dbResult) return dbResult;
-  return memStacks.get(id)?.manifest || null;
+// ../../lib/terminals-tech/machines/core/types/trigger.ts
+function buildScheduleTriggerContext(config, scheduleId) {
+  return {
+    triggerKind: config.kind,
+    triggeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cronExpression: config.kind === "cron" ? config.expression : void 0,
+    scheduleId
+  };
 }
 
 // ../../lib/terminals-tech/machines/core/manifests.ts
@@ -557,7 +544,7 @@ var OrchestratorV0 = class {
       return true;
     }
     try {
-      const { neuroState } = await import("./neuro-state-XHRGIRVO.js");
+      const { neuroState } = await import("./neuro-state-KINIFV2D.js");
       const currentState = await new Promise((resolve) => {
         let resolved = false;
         let subscription = null;
@@ -680,8 +667,8 @@ var OrchestratorV0 = class {
       };
       let shapeHash;
       try {
-        const { computeShapeHash: computeShapeHash2 } = await import("./topology-CIWWNVAN.js");
-        shapeHash = await computeShapeHash2(stack);
+        const { computeShapeHash } = await import("./topology-CIWWNVAN.js");
+        shapeHash = await computeShapeHash(stack);
       } catch (err) {
         console.error("[OrchestratorV0] Failed to compute shape hash:", err);
       }
@@ -695,6 +682,44 @@ var OrchestratorV0 = class {
           ...baseInput,
           ...opts.configOverrides?.[node.id] || {}
         };
+        if (isNodeManifest(manifest) && manifest.inputsSchema && opts.configOverrides?.[node.id]) {
+          try {
+            const validator = getValidator(manifest.inputsSchema);
+            const publicInput = {};
+            for (const [k, v] of Object.entries(input)) {
+              if (!k.startsWith("__")) publicInput[k] = v;
+            }
+            const isValid = validator(publicInput);
+            if (!isValid) {
+              console.warn(
+                `[OrchestratorV0] configOverrides for node "${node.id}" produced input that does not match inputsSchema:`,
+                validator.errors
+              );
+            }
+          } catch (schemaErr) {
+            console.warn(
+              `[OrchestratorV0] Failed to validate configOverrides for node "${node.id}":`,
+              schemaErr
+            );
+          }
+        }
+        if (opts.triggerContext) {
+          input.__triggerContext = opts.triggerContext;
+        }
+        if (node.connectorRef) {
+          try {
+            const { resolveConnectorData } = await import("./resolver-ALOJSOK5.js");
+            const chunks = await resolveConnectorData(node.connectorRef);
+            if (chunks && chunks.length > 0) {
+              input.__connectorData = chunks;
+            }
+          } catch (connErr) {
+            console.warn(
+              `[OrchestratorV0] ConnectorRef resolution failed for node ${node.id}:`,
+              connErr
+            );
+          }
+        }
         const modelId = input.model || node.config?.model || "default";
         const span = this.tracer.startSpan(`node:${node.id}`, {
           stackId: stack.id,
@@ -895,10 +920,10 @@ var OrchestratorV0 = class {
     void stackId;
     void node;
     if (typeof window === "undefined") {
-      const { ensureServerRunnersRegistered } = await import("./server-7DM74VFW.js");
+      const { ensureServerRunnersRegistered } = await import("./server-JXM4Y2T6.js");
       await ensureServerRunnersRegistered();
     }
-    const { runners } = await import("./registry-BL3TDQDB.js");
+    const { runners } = await import("./registry-UARRB6CF.js");
     const tierRunner = runners.getRunner(tier);
     if (tierRunner) {
       return await tierRunner(manifest, input, {
@@ -944,7 +969,7 @@ var OrchestratorV0 = class {
       return { ...input };
     }
     if (tier === "webcontainer") {
-      const { runInWebContainer } = await import("./webcontainer-3LDJVIIL.js");
+      const { runInWebContainer } = await import("./webcontainer-PMWNRO4I.js");
       return await runInWebContainer(manifest, input, {
         stackId,
         nodeId: node.id,
@@ -952,7 +977,7 @@ var OrchestratorV0 = class {
       });
     }
     if (tier === "wasm-hvm") {
-      const { runInHVM } = await import("./hvm-DRQK2MUT.js");
+      const { runInHVM } = await import("./hvm-A7DGZ3Q5.js");
       return await runInHVM(manifest, input, {
         stackId,
         nodeId: node.id,
@@ -972,6 +997,6 @@ var OrchestratorV0 = class {
 };
 
 export {
-  loadStack,
+  buildScheduleTriggerContext,
   OrchestratorV0
 };