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

package/dist/chunk-PKINKOW2.js

@@ -0,0 +1,335 @@
+// ../../lib/terminals-tech/core/L0/information.ts
+function entropy(probabilities) {
+  if (probabilities.length === 0) return 0;
+  const sum = probabilities.reduce((a, b) => a + b, 0);
+  const normalized = sum === 0 ? probabilities : probabilities.map((p) => p / sum);
+  return normalized.reduce((h, p) => {
+    if (p <= 0) return h;
+    return h - p * Math.log2(p);
+  }, 0);
+}
+function jointEntropy(jointProbabilities) {
+  const flat = jointProbabilities.flat();
+  return entropy(flat);
+}
+function conditionalEntropy(jointProbabilities) {
+  const hXY = jointEntropy(jointProbabilities);
+  const pX = jointProbabilities.map((row) => row.reduce((a, b) => a + b, 0));
+  const hX = entropy(pX);
+  return hXY - hX;
+}
+function mutualInformation(pX, pY, pXY) {
+  const hX = entropy(pX);
+  const hY = entropy(pY);
+  const hXY = jointEntropy(pXY);
+  return Math.max(0, hX + hY - hXY);
+}
+function measurePreservation(source, transformed, roundTrip) {
+  if (source.length === 0) {
+    return {
+      retention: 1,
+      sourceEntropy: 0,
+      targetEntropy: 0,
+      mutualInfo: 0,
+      lossless: true
+    };
+  }
+  const sourceFreq = countFrequencies(source.map(String));
+  const transformedFreq = countFrequencies(transformed.map(String));
+  const n = source.length;
+  const sourceProbabilities = Object.values(sourceFreq).map((c) => c / n);
+  const transformedProbabilities = Object.values(transformedFreq).map((c) => c / n);
+  const sourceEntropy = entropy(sourceProbabilities);
+  const targetEntropy = entropy(transformedProbabilities);
+  let retention = 1;
+  let lossless = true;
+  if (roundTrip) {
+    const matches = source.filter((s, i) => String(s) === String(roundTrip[i])).length;
+    retention = matches / source.length;
+    lossless = matches === source.length;
+  } else {
+    const sourceCardinality = Object.keys(sourceFreq).length;
+    const targetCardinality = Object.keys(transformedFreq).length;
+    retention = Math.min(1, targetCardinality / sourceCardinality);
+    lossless = targetCardinality >= sourceCardinality;
+  }
+  const minEntropy = Math.min(sourceEntropy, targetEntropy);
+  const mutualInfo = retention * minEntropy;
+  return {
+    retention,
+    sourceEntropy,
+    targetEntropy,
+    mutualInfo,
+    lossless
+  };
+}
+function calculateSemanticDensity(tokens, baselineTokensPerBit = 2) {
+  if (tokens.length === 0) {
+    return {
+      tokenCount: 0,
+      informationBits: 0,
+      density: 0,
+      compressionRatio: 1
+    };
+  }
+  const freq = countFrequencies(tokens);
+  const probabilities = Object.values(freq).map((c) => c / tokens.length);
+  const informationBits = entropy(probabilities) * tokens.length;
+  const density = tokens.length > 0 ? informationBits / tokens.length : 0;
+  const baselineBits = tokens.length / baselineTokensPerBit;
+  const compressionRatio = baselineBits > 0 ? informationBits / baselineBits : 1;
+  return {
+    tokenCount: tokens.length,
+    informationBits,
+    density,
+    compressionRatio
+  };
+}
+function estimateComplexity(data) {
+  if (data.length === 0) return 0;
+  const seen = /* @__PURE__ */ new Set();
+  let uniqueSubstrings = 0;
+  const windowSize = 8;
+  for (let i = 0; i <= data.length - windowSize; i++) {
+    const substr = data.slice(i, i + windowSize);
+    if (!seen.has(substr)) {
+      seen.add(substr);
+      uniqueSubstrings++;
+    }
+  }
+  const totalPatterns = Math.max(1, data.length - windowSize + 1);
+  return uniqueSubstrings / totalPatterns;
+}
+function klDivergence(p, q) {
+  if (p.length !== q.length) {
+    throw new Error("Distributions must have same length");
+  }
+  let divergence = 0;
+  for (let i = 0; i < p.length; i++) {
+    if (p[i] > 0 && q[i] > 0) {
+      divergence += p[i] * Math.log2(p[i] / q[i]);
+    } else if (p[i] > 0 && q[i] === 0) {
+      return Infinity;
+    }
+  }
+  return divergence;
+}
+function jsDivergence(p, q) {
+  if (p.length !== q.length) {
+    throw new Error("Distributions must have same length");
+  }
+  const m = p.map((pi, i) => 0.5 * (pi + q[i]));
+  let jsd = 0;
+  for (let i = 0; i < p.length; i++) {
+    if (p[i] > 0 && m[i] > 0) {
+      jsd += 0.5 * p[i] * Math.log2(p[i] / m[i]);
+    }
+    if (q[i] > 0 && m[i] > 0) {
+      jsd += 0.5 * q[i] * Math.log2(q[i] / m[i]);
+    }
+  }
+  return jsd;
+}
+function countFrequencies(values) {
+  const freq = {};
+  for (const v of values) {
+    const key = String(v);
+    freq[key] = (freq[key] || 0) + 1;
+  }
+  return freq;
+}
+function normalize(values) {
+  const sum = values.reduce((a, b) => a + b, 0);
+  if (sum === 0) return values.map(() => 1 / values.length);
+  return values.map((v) => v / sum);
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length || a.length === 0) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  return denominator === 0 ? 0 : dot / denominator;
+}
+
+// ../../lib/terminals-tech/core/L0/sematon.ts
+var sematonCounter = 0;
+function fnv1a(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function computePayloadEntropy(payload) {
+  const json = JSON.stringify(payload);
+  if (!json || json.length === 0) return 0;
+  const freq = {};
+  for (let i = 0; i < json.length; i++) {
+    const ch = json[i];
+    freq[ch] = (freq[ch] || 0) + 1;
+  }
+  const probabilities = Object.values(freq).map((c) => c / json.length);
+  return entropy(probabilities);
+}
+function computeDensity(payload, entropyBits) {
+  const json = JSON.stringify(payload);
+  const tokenCount = json ? json.split(/\s+|[,{}[\]":]+/).filter(Boolean).length : 0;
+  return tokenCount > 0 ? entropyBits / tokenCount : 0;
+}
+function generatePadicAddress(kind, counter) {
+  const kindIndex = [
+    "signal",
+    "context",
+    "fractal",
+    "witness",
+    "combinator",
+    "interaction",
+    "custom"
+  ].indexOf(kind);
+  return `${kindIndex}.0.${counter}`;
+}
+function createSematon(config) {
+  const counter = ++sematonCounter;
+  const id = `sem_${config.kind}_${counter}_${Date.now().toString(36)}`;
+  const payloadEntropy = computePayloadEntropy(config.payload);
+  const density = computeDensity(config.payload, payloadEntropy);
+  const padicAddress = config.padicAddress ?? generatePadicAddress(config.kind, counter);
+  const hashInput = [
+    config.kind,
+    JSON.stringify(config.payload),
+    config.witness.R.toFixed(6),
+    config.witness.converged.toString(),
+    padicAddress
+  ].join("|");
+  const shapeHash = fnv1a(hashInput);
+  const constructive = config.witness.converged && Number.isFinite(payloadEntropy) && payloadEntropy > 0 && JSON.stringify(config.payload) !== "null" && JSON.stringify(config.payload) !== "undefined";
+  const impedance = density > 0 && config.witness.R > 0 ? payloadEntropy / (density * config.witness.R) : Infinity;
+  return {
+    id,
+    kind: config.kind,
+    payload: config.payload,
+    witness: { ...config.witness },
+    padicAddress,
+    entropy: payloadEntropy,
+    density,
+    impedance,
+    shapeHash,
+    constructive,
+    createdAt: Date.now(),
+    source: config.source ?? "unknown"
+  };
+}
+function sematonEntropy(sematon) {
+  return sematon.entropy;
+}
+function sematonDensity(sematon) {
+  return sematon.density;
+}
+function isRealizable(sematon) {
+  return sematon.constructive;
+}
+function sematonDistance(a, b) {
+  const vecA = payloadToVector(a.payload);
+  const vecB = payloadToVector(b.payload);
+  const cosSim = cosineSimilarity(vecA, vecB);
+  const rProximity = 1 - Math.abs(a.witness.R - b.witness.R);
+  const similarity = 0.7 * Math.max(0, cosSim) + 0.3 * rProximity;
+  return 1 - similarity;
+}
+function payloadToVector(payload) {
+  const json = JSON.stringify(payload);
+  const vec = new Array(128).fill(0);
+  if (!json) return vec;
+  for (let i = 0; i < json.length; i++) {
+    const code = json.charCodeAt(i);
+    if (code < 128) {
+      vec[code]++;
+    }
+  }
+  const sum = vec.reduce((s, v) => s + v, 0);
+  if (sum > 0) {
+    for (let i = 0; i < vec.length; i++) {
+      vec[i] /= sum;
+    }
+  }
+  return vec;
+}
+function foldSematon(sematon) {
+  return {
+    id: sematon.id,
+    kind: sematon.kind,
+    payload: JSON.stringify(sematon.payload),
+    witness: { ...sematon.witness },
+    padicAddress: sematon.padicAddress,
+    entropy: sematon.entropy,
+    density: sematon.density,
+    impedance: sematon.impedance,
+    shapeHash: sematon.shapeHash,
+    constructive: sematon.constructive,
+    createdAt: sematon.createdAt,
+    source: sematon.source
+  };
+}
+function unfoldSematon(folded) {
+  return {
+    id: folded.id,
+    kind: folded.kind,
+    payload: JSON.parse(folded.payload),
+    witness: { ...folded.witness },
+    padicAddress: folded.padicAddress,
+    entropy: folded.entropy,
+    density: folded.density,
+    impedance: folded.impedance,
+    shapeHash: folded.shapeHash,
+    constructive: folded.constructive,
+    createdAt: folded.createdAt,
+    source: folded.source
+  };
+}
+
+export {
+  entropy,
+  jointEntropy,
+  conditionalEntropy,
+  mutualInformation,
+  measurePreservation,
+  calculateSemanticDensity,
+  estimateComplexity,
+  klDivergence,
+  jsDivergence,
+  normalize,
+  cosineSimilarity,
+  createSematon,
+  sematonEntropy,
+  sematonDensity,
+  isRealizable,
+  sematonDistance,
+  foldSematon,
+  unfoldSematon
+};
+/**
+ * L0 Sematon — The Smallest Meaning-Bearing Unit
+ *
+ * The sematon is the atomic unit of operational meaning in Terminals OS.
+ * It carries a typed payload, convergence witness, p-adic address,
+ * information-theoretic metrics, and a constructor flag that guarantees
+ * the Deutsch-Marletto invariant: after transforming an input, the
+ * sematon retains the ability to transform again.
+ *
+ * The sematon unifies Signal<T>, ContextNode, FractalSnapshot,
+ * ConvergenceWitness, and CombinatorEvent into a single formal type
+ * at the L0 foundation layer.
+ *
+ * Core Engine Primitive.
+ *
+ * @license BUSL-1.1
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module core/L0/sematon
+ */

package/dist/chunk-PWEICJ47.js

@@ -0,0 +1,30 @@
+import {
+  registerManifestProvider
+} from "./chunk-WT6L6DK3.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, safeDbOperation } = await import("./pgliteService-IUGNNOVU.js");
+  const dbResult = await safeDbOperation(async () => {
+    const db = await getDB();
+    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;
+}
+
+export {
+  loadStack
+};

package/dist/{chunk-BKB3MD5Y.js → chunk-Q4W3IUTD.js}

@@ -1,6 +1,9 @@
 import {
   appendMeshSinkEvent
-} from "./chunk-PWAHFID5.js";
+} from "./chunk-D4MOOUDY.js";
+import {
+  getProvider
+} from "./chunk-H3POJCFA.js";
 import {
   blendResonance,
   cosineResonance,
@@ -10,9 +13,6 @@ import {
   phaseShift,
   toIQ
 } from "./chunk-WU4OTGJE.js";
-import {
-  registerNode
-} from "./chunk-3CEM77QZ.js";
 import {
   emitSignal
 } from "./chunk-2WTYE4SW.js";
@@ -20,6 +20,65 @@ import {
   Combinators,
   createPAdicAddress
 } from "./chunk-EXI3LJVJ.js";
+import {
+  registerNode
+} from "./chunk-WT6L6DK3.js";
+
+// ../../lib/terminals-tech/machines/core/nodes/provider.chat.ts
+var PROVIDER_CHAT_NODE_ID = "provider.chat.v1";
+var manifest = {
+  id: PROVIDER_CHAT_NODE_ID,
+  version: "0.1.0",
+  kind: "task",
+  label: "Provider Chat",
+  description: "Calls a chat model on a selected provider",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      provider: {
+        type: "string",
+        description: "provider id (openai, nous, prime, ...)"
+      },
+      model: { type: "string" },
+      messages: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { role: { type: "string" }, content: { type: "string" } },
+          required: ["role", "content"]
+        }
+      },
+      temperature: { type: "number" },
+      secretRef: {
+        type: "string",
+        description: "reference key in Secrets store"
+      },
+      baseUrl: { type: "string", description: "override baseUrl for vendor" }
+    },
+    required: ["provider", "model", "messages"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { message: { type: "string" }, usage: { type: "object" } }
+  }
+};
+registerNode(manifest);
+async function executeProviderChat(inputs, context) {
+  const adapter = getProvider(inputs.provider);
+  if (!adapter?.chat?.generate) throw new Error(`provider not found: ${inputs.provider}`);
+  const secrets = inputs.secretRef && context.getSecret ? await context.getSecret(inputs.secretRef) : {};
+  const out = await adapter.chat.generate(
+    {
+      model: inputs.model,
+      messages: inputs.messages,
+      temperature: inputs.temperature
+    },
+    secrets
+  );
+  return { message: out.message, usage: out.usage };
+}
 
 // ../../lib/terminals-tech/machines/hvm/bridge.ts
 function calculateValuation(node) {
@@ -100,7 +159,7 @@ function hvmToLogitBias(trace, baseMagnitude = 0.15) {
 
 // ../../lib/terminals-tech/machines/core/nodes/hvm.proof.edgeCheck.ts
 var HVM_PROOF_EDGE_CHECK_NODE_ID = "hvm.proof.edgeCheck.v1";
-var manifest = {
+var manifest2 = {
   id: HVM_PROOF_EDGE_CHECK_NODE_ID,
   version: "0.1.0",
   kind: "transform",
@@ -175,7 +234,7 @@ var manifest = {
     required: ["ok", "proofTrace"]
   }
 };
-registerNode(manifest);
+registerNode(manifest2);
 function hasPath(edges, from, to, visited = /* @__PURE__ */ new Set()) {
   if (from === to) return true;
   if (visited.has(from)) return false;
@@ -306,7 +365,7 @@ async function executeHvmProofEdgeCheck(input, ctx) {
 
 // ../../lib/terminals-tech/machines/core/nodes/compute.bend.ts
 var COMPUTE_BEND_NODE_ID = "compute.bend.v1";
-var manifest2 = {
+var manifest3 = {
   id: COMPUTE_BEND_NODE_ID,
   version: "0.1.0",
   kind: "task",
@@ -349,7 +408,7 @@ var manifest2 = {
     required: ["ok"]
   }
 };
-registerNode(manifest2);
+registerNode(manifest3);
 async function executeBendCompute(input, ctx) {
   const rawModule = String(input.hvmModule || "");
   const bendPath = String(input.bendPath || "");
@@ -365,7 +424,7 @@ async function executeBendCompute(input, ctx) {
       bendSource: bendSource ? "present" : "absent"
     };
   }
-  const { runInHVM } = await import("./hvm-DRQK2MUT.js");
+  const { runInHVM } = await import("./hvm-A7DGZ3Q5.js");
   const manifestOverride = {
     id: COMPUTE_BEND_NODE_ID,
     version: "0.1.0",
@@ -670,7 +729,7 @@ async function executePhaseLockingValueNode(inputs) {
 
 // ../../lib/terminals-tech/machines/core/nodes/system.schedule.ts
 var SYSTEM_SCHEDULE_NODE_ID = "system.schedule.v1";
-var manifest3 = {
+var manifest4 = {
   id: SYSTEM_SCHEDULE_NODE_ID,
   version: "0.1.0",
   kind: "task",
@@ -694,9 +753,9 @@ var manifest3 = {
     }
   }
 };
-registerNode(manifest3);
+registerNode(manifest4);
 async function executeSystemSchedule(_input, ctx) {
-  const { scheduleStack } = await import("./scheduler-H6Q53IMI.js");
+  const { scheduleStack } = await import("./scheduler-SAQJLKXJ.js");
   const everySeconds = Math.max(1, Number(_input.everySeconds || 60));
   const enabled = Boolean(_input.enabled ?? true);
   if (enabled) await scheduleStack(ctx.stackId, everySeconds);
@@ -704,6 +763,8 @@ async function executeSystemSchedule(_input, ctx) {
 }
 
 export {
+  PROVIDER_CHAT_NODE_ID,
+  executeProviderChat,
   HVM_PROOF_EDGE_CHECK_NODE_ID,
   executeHvmProofEdgeCheck,
   COMPUTE_BEND_NODE_ID,

package/dist/{chunk-BCOQMFKT.js → chunk-TO7ETE5K.js}

@@ -258,8 +258,8 @@ function sanitizeTraceSegment(value, maxLen = 48) {
 export {
   createInteractionWithEvents,
   transitionStatusWithEvent,
-  sanitizeTraceSegment,
   parseAddress,
   formatAddress,
-  createAddress
+  createAddress,
+  sanitizeTraceSegment
 };

package/dist/{chunk-Q2VI6ICE.js → chunk-UB5OINTA.js}

@@ -4,7 +4,7 @@ import {
   recordRunStart,
   recordSystemPause,
   recordSystemResume
-} from "./chunk-PWAHFID5.js";
+} from "./chunk-D4MOOUDY.js";
 import {
   getSignalBus
 } from "./chunk-2WTYE4SW.js";

package/dist/{chunk-Q4B7YS7T.js → chunk-WJCIX7RO.js}

@@ -5,6 +5,7 @@ import {
   BASE_RESONANCE_METRICS_NODE_ID,
   COMPUTE_BEND_NODE_ID,
   HVM_PROOF_EDGE_CHECK_NODE_ID,
+  PROVIDER_CHAT_NODE_ID,
   SYSTEM_SCHEDULE_NODE_ID,
   SYSTEM_SIGNAL_EMIT_NODE_ID,
   executeBendCompute,
@@ -12,16 +13,11 @@ import {
   executeIqEncode,
   executeIqPhaseShift,
   executePhaseLockingValueNode,
+  executeProviderChat,
   executeResonanceMetrics,
   executeSystemSchedule,
   executeSystemSignalEmit
-} from "./chunk-BKB3MD5Y.js";
-import {
-  getProvider
-} from "./chunk-H3POJCFA.js";
-import {
-  registerNode
-} from "./chunk-3CEM77QZ.js";
+} from "./chunk-Q4W3IUTD.js";
 
 // ../../lib/types/safe-types.ts
 function isObject(value) {
@@ -34,62 +30,6 @@ function isString(value) {
   return typeof value === "string";
 }
 
-// ../../lib/terminals-tech/machines/core/nodes/provider.chat.ts
-var PROVIDER_CHAT_NODE_ID = "provider.chat.v1";
-var manifest = {
-  id: PROVIDER_CHAT_NODE_ID,
-  version: "0.1.0",
-  kind: "task",
-  label: "Provider Chat",
-  description: "Calls a chat model on a selected provider",
-  runtimes: ["worker"],
-  entrypoints: { worker: { module: "local" } },
-  inputsSchema: {
-    type: "object",
-    properties: {
-      provider: {
-        type: "string",
-        description: "provider id (openai, nous, prime, ...)"
-      },
-      model: { type: "string" },
-      messages: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: { role: { type: "string" }, content: { type: "string" } },
-          required: ["role", "content"]
-        }
-      },
-      temperature: { type: "number" },
-      secretRef: {
-        type: "string",
-        description: "reference key in Secrets store"
-      },
-      baseUrl: { type: "string", description: "override baseUrl for vendor" }
-    },
-    required: ["provider", "model", "messages"]
-  },
-  outputsSchema: {
-    type: "object",
-    properties: { message: { type: "string" }, usage: { type: "object" } }
-  }
-};
-registerNode(manifest);
-async function executeProviderChat(inputs, context) {
-  const adapter = getProvider(inputs.provider);
-  if (!adapter?.chat?.generate) throw new Error(`provider not found: ${inputs.provider}`);
-  const secrets = inputs.secretRef && context.getSecret ? await context.getSecret(inputs.secretRef) : {};
-  const out = await adapter.chat.generate(
-    {
-      model: inputs.model,
-      messages: inputs.messages,
-      temperature: inputs.temperature
-    },
-    secrets
-  );
-  return { message: out.message, usage: out.usage };
-}
-
 // ../../lib/terminals-tech/machines/core/runners/registry.ts
 var RunnerRegistry = class {
   workerRunners = /* @__PURE__ */ new Map();
@@ -134,8 +74,8 @@ var RunnerRegistry = class {
   }
 };
 var runners = new RunnerRegistry();
-import("./demo-VXMGMJNK.js").catch((err) => console.warn("[RunnerRegistry] demo runner import failed", err));
-import("./stack-CHDAFU2S.js").catch((err) => console.warn("[RunnerRegistry] stack runner import failed", err));
+import("./demo-WARANXBT.js").catch((err) => console.warn("[RunnerRegistry] demo runner import failed", err));
+import("./stack-4QQCK7MG.js").catch((err) => console.warn("[RunnerRegistry] stack runner import failed", err));
 runners.registerWorker(PROVIDER_CHAT_NODE_ID, async (_m, input, ctx) => {
   const typedInput = input;
   const secrets = typedInput.__secrets || {};
@@ -446,7 +386,7 @@ runners.registerWorker("intel.llm.http.v1", async (_m, input, ctx) => {
   };
 });
 runners.registerWorker("integration.source.poll.v1", async (_m, input, ctx) => {
-  const { getProvider: getProvider2 } = await import("./registry-FW63E7FE.js");
+  const { getProvider } = await import("./registry-FW63E7FE.js");
   const providerIdVal = isObject(input) && "provider" in input ? input.provider : void 0;
   const providerId = String(providerIdVal || "");
   const resourceVal = isObject(input) && "resource" in input ? input.resource : void 0;
@@ -455,7 +395,7 @@ runners.registerWorker("integration.source.poll.v1", async (_m, input, ctx) => {
   const config = isObject(configVal) ? configVal : {};
   const cursorKeyVal = isObject(input) && "cursorKey" in input ? input.cursorKey : void 0;
   const cursorKey = String(cursorKeyVal || `${providerId}:${resource}`);
-  const prov = getProvider2(providerId);
+  const prov = getProvider(providerId);
   if (!prov?.integration) throw new Error(`provider not found: ${providerId}`);
   const secrets = {};
   try {
@@ -495,7 +435,7 @@ runners.registerWorker("integration.source.poll.v1", async (_m, input, ctx) => {
   return { items, cursor: nextCursor };
 });
 runners.registerWorker("integration.sink.post.v1", async (_m, input, ctx) => {
-  const { getProvider: getProvider2 } = await import("./registry-FW63E7FE.js");
+  const { getProvider } = await import("./registry-FW63E7FE.js");
   const providerIdVal = isObject(input) && "provider" in input ? input.provider : void 0;
   const providerId = String(providerIdVal || "");
   const resourceVal = isObject(input) && "resource" in input ? input.resource : void 0;
@@ -506,7 +446,7 @@ runners.registerWorker("integration.sink.post.v1", async (_m, input, ctx) => {
   const itemsVal = isObject(input) && "items" in input ? input.items : void 0;
   const itemsArray = isArray(itemsVal) ? itemsVal : void 0;
   const items = itemsArray || (singleItem !== void 0 ? [singleItem] : []);
-  const prov = getProvider2(providerId);
+  const prov = getProvider(providerId);
   if (!prov?.integration) throw new Error(`provider not found: ${providerId}`);
   const secrets = {};
   try {