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

package/dist/chunk-EXI3LJVJ.js

@@ -0,0 +1,51 @@
+// ../../lib/terminals-tech/core/primitives/types.ts
+var Combinators = {
+  /** γ - Decompose task into subtasks */
+  CONSTRUCT: "\u03B3",
+  /** δ - Spawn parallel execution paths */
+  DUPLICATE: "\u03B4",
+  /** ε - Fold/aggregate results */
+  ERASE: "\u03B5"
+};
+function createPAdicAddress(base, coefficients = []) {
+  if (base < 2) {
+    throw new Error(`P-adic base must be >= 2, got ${base}`);
+  }
+  for (const c of coefficients) {
+    if (c < 0 || c >= base) {
+      throw new Error(`Coefficient ${c} must be in [0, ${base - 1}] for base ${base}`);
+    }
+  }
+  return { base, coefficients: Object.freeze([...coefficients]) };
+}
+function validated(value) {
+  return Object.assign(value, { _validated: true });
+}
+function unbrand(value) {
+  const obj = value;
+  delete obj._validated;
+  return obj;
+}
+function untrusted(value) {
+  if (value === null || value === void 0 || typeof value !== "object") {
+    return { value, _untrusted: true };
+  }
+  return Object.assign(value, { _untrusted: true });
+}
+function validate(value, validator) {
+  const raw = { ...value };
+  delete raw._untrusted;
+  if (validator(raw)) {
+    return validated(raw);
+  }
+  return null;
+}
+
+export {
+  Combinators,
+  createPAdicAddress,
+  validated,
+  unbrand,
+  untrusted,
+  validate
+};

package/dist/chunk-FOXUEYWK.js

@@ -0,0 +1,42 @@
+import {
+  untrusted,
+  validate
+} from "./chunk-EXI3LJVJ.js";
+import {
+  require_ajv
+} from "./chunk-QJFKEQHF.js";
+import {
+  __toESM
+} from "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/core/primitives/validation.ts
+var import_ajv = __toESM(require_ajv());
+var ajv = new import_ajv.default({ allErrors: true });
+var validatorCache = /* @__PURE__ */ new Map();
+function getValidator(schema) {
+  const schemaStr = JSON.stringify(schema);
+  if (validatorCache.has(schemaStr)) {
+    return validatorCache.get(schemaStr);
+  }
+  const validateFn = ajv.compile(schema);
+  validatorCache.set(schemaStr, validateFn);
+  return validateFn;
+}
+function validateWithSchema(data, schema) {
+  const validator = getValidator(schema);
+  return validate(data, (raw) => {
+    const isValid = validator(raw);
+    if (!isValid) {
+      console.warn("[Validation] Schema validation failed:", validator.errors);
+    }
+    return !!isValid;
+  });
+}
+function secureValidate(data, schema) {
+  return validateWithSchema(untrusted(data), schema);
+}
+
+export {
+  validateWithSchema,
+  secureValidate
+};

package/dist/chunk-GJWAJAX3.js

@@ -0,0 +1,173 @@
+import {
+  __require
+} from "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/machines/core/topology.ts
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function normalizeRuntimes(r) {
+  if (!r) return void 0;
+  const normalized = {};
+  if (r.default && Array.isArray(r.default)) normalized.default = [...r.default].slice().sort();
+  if (r.overrides) {
+    const entries = Object.entries(r.overrides).map(
+      ([nodeId, tiers]) => [nodeId, [...tiers].slice().sort()]
+    );
+    entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    normalized.overrides = Object.fromEntries(entries);
+  }
+  return normalized;
+}
+function normalizePolicies(p) {
+  if (!p) return void 0;
+  const normalized = {};
+  if (p.fs) {
+    normalized.fs = { mode: p.fs.mode };
+    if (p.fs.allowedPaths) normalized.fs.allowedPaths = [...p.fs.allowedPaths].slice().sort();
+  }
+  if (p.network) {
+    normalized.network = { egress: p.network.egress };
+    if (p.network.allowList) normalized.network.allowList = [...p.network.allowList].slice().sort();
+  }
+  return normalized;
+}
+function normalizeNode(n) {
+  const out = {
+    id: n.id,
+    nodeRef: n.nodeRef
+  };
+  if (n.runtimes && n.runtimes.length > 0) out.runtimes = [...n.runtimes].slice().sort();
+  if (n.policies) out.policies = normalizePolicies(n.policies);
+  if (n.secrets && n.secrets.length > 0) out.secrets = [...n.secrets].slice().sort();
+  return out;
+}
+function normalizeEdge(e) {
+  const ce = { from: e.from, to: e.to };
+  if (e.map) {
+    const pairs = Object.entries(e.map).map(([outKey, inKey]) => ({
+      outKey,
+      inKey
+    }));
+    pairs.sort(
+      (a, b) => a.outKey < b.outKey ? -1 : a.outKey > b.outKey ? 1 : a.inKey < b.inKey ? -1 : a.inKey > b.inKey ? 1 : 0
+    );
+    ce.map = pairs;
+  }
+  return ce;
+}
+function normalizeSecrets(s) {
+  if (!s) return void 0;
+  const entries = Object.entries(s).map(
+    ([name, rec]) => [name, { scope: [...rec.scope].slice().sort(), required: rec.required }]
+  );
+  entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  return Object.fromEntries(entries);
+}
+function canonicalizeStack(manifest) {
+  const m = clone(manifest);
+  const nodes = (m.nodes || []).map(normalizeNode).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  const edges = (m.edges || []).map(normalizeEdge).sort((a, b) => {
+    if (a.from !== b.from) return a.from < b.from ? -1 : 1;
+    return a.to < b.to ? -1 : a.to > b.to ? 1 : 0;
+  });
+  return {
+    version: m.version,
+    name: m.name || void 0,
+    nodes,
+    edges,
+    policies: normalizePolicies(m.policies),
+    runtimes: normalizeRuntimes(m.runtimes),
+    secrets: normalizeSecrets(m.secrets),
+    layer: m.layer
+  };
+}
+function stableStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  function walk(v) {
+    if (v === null || typeof v !== "object") return v;
+    if (seen.has(v)) return v;
+    seen.add(v);
+    if (Array.isArray(v)) return v.map(walk);
+    const out = {};
+    for (const key of Object.keys(v).sort()) {
+      out[key] = walk(v[key]);
+    }
+    return out;
+  }
+  return JSON.stringify(walk(value));
+}
+async function sha256Hex(input) {
+  try {
+    if (typeof crypto !== "undefined" && crypto.subtle) {
+      const enc = new TextEncoder().encode(input);
+      const buf = await crypto.subtle.digest("SHA-256", enc);
+      const bytes = Array.from(new Uint8Array(buf));
+      return bytes.map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+  } catch {
+  }
+  try {
+    const nodeCrypto = __require("crypto");
+    return nodeCrypto.createHash("sha256").update(input).digest("hex");
+  } catch {
+  }
+  let hashHigh = 3421674724;
+  let hashLow = 2216829733;
+  for (let i = 0; i < input.length; i++) {
+    const code = input.charCodeAt(i);
+    hashLow ^= code;
+    const low = hashLow * 435 >>> 0;
+    const carry = Math.floor(hashLow * 435 / 4294967296);
+    const high = hashHigh * 435 + carry >>> 0;
+    hashLow = low;
+    hashHigh = high;
+  }
+  return (hashHigh >>> 0).toString(16).padStart(8, "0") + (hashLow >>> 0).toString(16).padStart(8, "0");
+}
+async function computeShapeHash(manifest, fsTreeHash) {
+  const canonical = canonicalizeStack(manifest);
+  const payload = {
+    canonical,
+    fsTreeHash: fsTreeHash || "fs:none",
+    domain: canonical.layer || "L1"
+    // layer-aware domain separation
+  };
+  const text = stableStringify(payload);
+  return await sha256Hex(text);
+}
+function adjacencyMatrix(nodes, edges) {
+  const index = {};
+  nodes.forEach((n, i) => {
+    index[n.id] = i;
+  });
+  const N = nodes.length;
+  const A = Array.from({ length: N }, () => Array(N).fill(0));
+  for (const e of edges) {
+    const i = index[e.from], j = index[e.to];
+    if (i !== void 0 && j !== void 0) A[i][j] = 1;
+  }
+  return A;
+}
+function incidenceMatrix(nodes, edges) {
+  const index = {};
+  nodes.forEach((n, i) => {
+    index[n.id] = i;
+  });
+  const E = edges.length;
+  const N = nodes.length;
+  const B = Array.from({ length: N }, () => Array(E).fill(0));
+  edges.forEach((e, k) => {
+    const i = index[e.from], j = index[e.to];
+    if (i !== void 0) B[i][k] = -1;
+    if (j !== void 0) B[j][k] = 1;
+  });
+  return B;
+}
+
+export {
+  canonicalizeStack,
+  computeShapeHash,
+  adjacencyMatrix,
+  incidenceMatrix
+};

package/dist/chunk-H3POJCFA.js

@@ -0,0 +1,333 @@
+import {
+  BRAND,
+  DIRTY,
+  EMPTY_PATH,
+  INVALID,
+  NEVER,
+  OK,
+  ParseStatus,
+  ZodAny,
+  ZodArray,
+  ZodBigInt,
+  ZodBoolean,
+  ZodBranded,
+  ZodCatch,
+  ZodDate,
+  ZodDefault,
+  ZodDiscriminatedUnion,
+  ZodEffects,
+  ZodEnum,
+  ZodError,
+  ZodFirstPartyTypeKind,
+  ZodFunction,
+  ZodIntersection,
+  ZodIssueCode,
+  ZodLazy,
+  ZodLiteral,
+  ZodMap,
+  ZodNaN,
+  ZodNativeEnum,
+  ZodNever,
+  ZodNull,
+  ZodNullable,
+  ZodNumber,
+  ZodObject,
+  ZodOptional,
+  ZodParsedType,
+  ZodPipeline,
+  ZodPromise,
+  ZodReadonly,
+  ZodRecord,
+  ZodSet,
+  ZodString,
+  ZodSymbol,
+  ZodTuple,
+  ZodType,
+  ZodUndefined,
+  ZodUnion,
+  ZodUnknown,
+  ZodVoid,
+  addIssueToContext,
+  anyType,
+  arrayType,
+  bigIntType,
+  booleanType,
+  coerce,
+  custom,
+  dateType,
+  datetimeRegex,
+  discriminatedUnionType,
+  effectsType,
+  en_default,
+  enumType,
+  functionType,
+  getErrorMap,
+  getParsedType,
+  instanceOfType,
+  intersectionType,
+  isAborted,
+  isAsync,
+  isDirty,
+  isValid,
+  late,
+  lazyType,
+  literalType,
+  makeIssue,
+  mapType,
+  nanType,
+  nativeEnumType,
+  neverType,
+  nullType,
+  nullableType,
+  numberType,
+  objectType,
+  objectUtil,
+  oboolean,
+  onumber,
+  optionalType,
+  ostring,
+  pipelineType,
+  preprocessType,
+  promiseType,
+  quotelessJson,
+  recordType,
+  setErrorMap,
+  setType,
+  strictObjectType,
+  stringType,
+  symbolType,
+  tupleType,
+  undefinedType,
+  unionType,
+  unknownType,
+  util,
+  voidType
+} from "./chunk-KHR7ZYCX.js";
+import {
+  __export
+} from "./chunk-2ESYSVXG.js";
+
+// ../../node_modules/zod/v3/external.js
+var external_exports = {};
+__export(external_exports, {
+  BRAND: () => BRAND,
+  DIRTY: () => DIRTY,
+  EMPTY_PATH: () => EMPTY_PATH,
+  INVALID: () => INVALID,
+  NEVER: () => NEVER,
+  OK: () => OK,
+  ParseStatus: () => ParseStatus,
+  Schema: () => ZodType,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBigInt: () => ZodBigInt,
+  ZodBoolean: () => ZodBoolean,
+  ZodBranded: () => ZodBranded,
+  ZodCatch: () => ZodCatch,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodEffects: () => ZodEffects,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNativeEnum: () => ZodNativeEnum,
+  ZodNever: () => ZodNever,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodParsedType: () => ZodParsedType,
+  ZodPipeline: () => ZodPipeline,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRecord: () => ZodRecord,
+  ZodSchema: () => ZodType,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodSymbol: () => ZodSymbol,
+  ZodTransformer: () => ZodEffects,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  addIssueToContext: () => addIssueToContext,
+  any: () => anyType,
+  array: () => arrayType,
+  bigint: () => bigIntType,
+  boolean: () => booleanType,
+  coerce: () => coerce,
+  custom: () => custom,
+  date: () => dateType,
+  datetimeRegex: () => datetimeRegex,
+  defaultErrorMap: () => en_default,
+  discriminatedUnion: () => discriminatedUnionType,
+  effect: () => effectsType,
+  enum: () => enumType,
+  function: () => functionType,
+  getErrorMap: () => getErrorMap,
+  getParsedType: () => getParsedType,
+  instanceof: () => instanceOfType,
+  intersection: () => intersectionType,
+  isAborted: () => isAborted,
+  isAsync: () => isAsync,
+  isDirty: () => isDirty,
+  isValid: () => isValid,
+  late: () => late,
+  lazy: () => lazyType,
+  literal: () => literalType,
+  makeIssue: () => makeIssue,
+  map: () => mapType,
+  nan: () => nanType,
+  nativeEnum: () => nativeEnumType,
+  never: () => neverType,
+  null: () => nullType,
+  nullable: () => nullableType,
+  number: () => numberType,
+  object: () => objectType,
+  objectUtil: () => objectUtil,
+  oboolean: () => oboolean,
+  onumber: () => onumber,
+  optional: () => optionalType,
+  ostring: () => ostring,
+  pipeline: () => pipelineType,
+  preprocess: () => preprocessType,
+  promise: () => promiseType,
+  quotelessJson: () => quotelessJson,
+  record: () => recordType,
+  set: () => setType,
+  setErrorMap: () => setErrorMap,
+  strictObject: () => strictObjectType,
+  string: () => stringType,
+  symbol: () => symbolType,
+  transformer: () => effectsType,
+  tuple: () => tupleType,
+  undefined: () => undefinedType,
+  union: () => unionType,
+  unknown: () => unknownType,
+  util: () => util,
+  void: () => voidType
+});
+
+// ../../lib/terminals-tech/machines/core/providers/registry.ts
+var ChatMessage = external_exports.object({
+  role: external_exports.enum(["system", "user", "assistant"]),
+  content: external_exports.string()
+});
+var ChatGenerateInput = external_exports.object({
+  model: external_exports.string(),
+  messages: external_exports.array(ChatMessage),
+  temperature: external_exports.number().optional()
+});
+var TokenUsage = external_exports.object({
+  prompt_tokens: external_exports.number().optional(),
+  completion_tokens: external_exports.number().optional(),
+  total_tokens: external_exports.number().optional()
+}).passthrough();
+var ChatGenerateOutput = external_exports.object({
+  message: external_exports.string(),
+  usage: TokenUsage.optional(),
+  raw: external_exports.record(external_exports.unknown()).optional()
+});
+var registry = /* @__PURE__ */ new Map();
+function registerProvider(p) {
+  registry.set(p.id, p);
+}
+function getProvider(id) {
+  return registry.get(id);
+}
+registerProvider({
+  id: "openai",
+  chat: {
+    async generate(input, secrets) {
+      ChatGenerateInput.parse(input);
+      const apiKey = secrets["apiKey"] || secrets["OPENAI_API_KEY"];
+      const baseUrl = secrets["baseUrl"] || "https://api.openai.com/v1";
+      const res = await fetch(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+        },
+        body: JSON.stringify({
+          model: input.model,
+          messages: input.messages,
+          temperature: input.temperature ?? 0.2
+        })
+      });
+      if (!res.ok) throw new Error(`chat.generate failed: ${res.status}`);
+      const j = await res.json();
+      const message = j?.choices?.[0]?.message?.content || "";
+      return { message, usage: j?.usage, raw: j };
+    }
+  }
+});
+var allowExperimentalProviders = process.env.NODE_ENV !== "production" || process.env.ENABLE_EXPERIMENTAL_PROVIDERS === "true";
+if (allowExperimentalProviders) {
+  registerProvider({
+    id: "nous",
+    chat: {
+      async generate(input, secrets) {
+        const baseUrl = secrets["baseUrl"] || "https://api.nous.example/v1";
+        const apiKey = secrets["apiKey"] || "";
+        const res = await fetch(`${baseUrl}/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+          },
+          body: JSON.stringify({
+            model: input.model,
+            messages: input.messages
+          })
+        });
+        if (!res.ok) throw new Error(`nous chat ${res.status}`);
+        const j = await res.json();
+        const message = j?.choices?.[0]?.message?.content || "";
+        return { message, usage: j?.usage, raw: j };
+      }
+    }
+  });
+  registerProvider({
+    id: "prime",
+    chat: {
+      async generate(input, secrets) {
+        const baseUrl = secrets["baseUrl"] || "https://api.prime.example/v1";
+        const apiKey = secrets["apiKey"] || "";
+        const res = await fetch(`${baseUrl}/chat`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...apiKey ? { "X-API-Key": apiKey } : {}
+          },
+          body: JSON.stringify({
+            model: input.model,
+            messages: input.messages
+          })
+        });
+        if (!res.ok) throw new Error(`prime chat ${res.status}`);
+        const j = await res.json();
+        const message = j?.output || j?.choices?.[0]?.message?.content || "";
+        return { message, usage: j?.usage, raw: j };
+      }
+    }
+  });
+}
+
+export {
+  ChatMessage,
+  ChatGenerateInput,
+  ChatGenerateOutput,
+  registerProvider,
+  getProvider
+};