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

package/dist/chunk-OSSRZOGC.js

@@ -0,0 +1,190 @@
+// ../../lib/errors/types.ts
+var ErrorCodes = {
+  // Auth errors
+  AUTH_TOKEN_EXPIRED: "AUTH_TOKEN_EXPIRED",
+  AUTH_TOKEN_REFRESH_FAILED: "AUTH_TOKEN_REFRESH_FAILED",
+  AUTH_SESSION_INVALID: "AUTH_SESSION_INVALID",
+  AUTH_INIT_RACE: "AUTH_INIT_RACE",
+  AUTH_PROVIDER_UNAVAILABLE: "AUTH_PROVIDER_UNAVAILABLE",
+  // Inference errors
+  INFERENCE_PROVIDER_UNAVAILABLE: "INFERENCE_PROVIDER_UNAVAILABLE",
+  INFERENCE_CIRCUIT_OPEN: "INFERENCE_CIRCUIT_OPEN",
+  INFERENCE_TIMEOUT: "INFERENCE_TIMEOUT",
+  INFERENCE_RATE_LIMITED: "INFERENCE_RATE_LIMITED",
+  INFERENCE_API_ERROR: "INFERENCE_API_ERROR",
+  // Sync errors
+  SYNC_CONFLICT: "SYNC_CONFLICT",
+  SYNC_OFFLINE: "SYNC_OFFLINE",
+  SYNC_FAILED: "SYNC_FAILED",
+  SYNC_LEADER_CHANGED: "SYNC_LEADER_CHANGED",
+  // MCP errors
+  MCP_CONNECTION_FAILED: "MCP_CONNECTION_FAILED",
+  MCP_TOOL_EXECUTION_FAILED: "MCP_TOOL_EXECUTION_FAILED",
+  MCP_SERVER_UNAVAILABLE: "MCP_SERVER_UNAVAILABLE",
+  // WebContainer errors
+  WEBCONTAINER_NOT_SUPPORTED: "WEBCONTAINER_NOT_SUPPORTED",
+  WEBCONTAINER_COOP_MISSING: "WEBCONTAINER_COOP_MISSING",
+  WEBCONTAINER_BOOT_FAILED: "WEBCONTAINER_BOOT_FAILED",
+  WEBCONTAINER_FS_ERROR: "WEBCONTAINER_FS_ERROR",
+  // Network errors
+  NETWORK_OFFLINE: "NETWORK_OFFLINE",
+  NETWORK_TIMEOUT: "NETWORK_TIMEOUT",
+  NETWORK_DNS_FAILED: "NETWORK_DNS_FAILED",
+  // Storage errors
+  STORAGE_QUOTA_EXCEEDED: "STORAGE_QUOTA_EXCEEDED",
+  STORAGE_ACCESS_DENIED: "STORAGE_ACCESS_DENIED",
+  STORAGE_CORRUPTED: "STORAGE_CORRUPTED",
+  // Platform errors
+  PLATFORM_STACK_FAILED: "PLATFORM_STACK_FAILED",
+  PLATFORM_NODE_FAILED: "PLATFORM_NODE_FAILED",
+  PLATFORM_TRAINING_FAILED: "PLATFORM_TRAINING_FAILED",
+  PLATFORM_TRAINING_NOT_CONFIGURED: "PLATFORM_TRAINING_NOT_CONFIGURED",
+  PLATFORM_TRAINING_UNAUTHORIZED: "PLATFORM_TRAINING_UNAUTHORIZED",
+  PLATFORM_TRAINING_OFFLINE: "PLATFORM_TRAINING_OFFLINE",
+  PLATFORM_TRAINING_RATE_LIMITED: "PLATFORM_TRAINING_RATE_LIMITED",
+  PLATFORM_TRAINING_INVALID_REQUEST: "PLATFORM_TRAINING_INVALID_REQUEST",
+  // Generic
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+  RUNAWAY_ERRORS: "RUNAWAY_ERRORS"
+};
+var DEFAULT_ERROR_BUS_CONFIG = {
+  dedupWindowMs: 5e3,
+  maxErrorsBeforeCutoff: 100,
+  retentionMs: 5 * 60 * 1e3,
+  maxPerSourcePerMinute: 10,
+  cutoffPauseMs: 3e4
+};
+
+// ../../lib/errors/base.ts
+var TerminalsError = class _TerminalsError extends Error {
+  /** Error source domain */
+  source;
+  /** Machine-readable error code */
+  code;
+  /** Error severity level */
+  severity;
+  /** Whether the operation can be retried */
+  retryable;
+  /** Whether error should be shown to user */
+  userFacing;
+  /** Additional context/metadata */
+  metadata;
+  /** Original error if this wraps another error */
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = this.constructor.name;
+    this.source = options.source;
+    this.code = options.code;
+    this.severity = options.severity ?? "error";
+    this.retryable = options.retryable ?? false;
+    this.userFacing = options.userFacing ?? false;
+    this.metadata = options.metadata;
+    this.cause = options.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Convert to ErrorInput for error bus emission.
+   */
+  toErrorInput() {
+    return {
+      source: this.source,
+      severity: this.severity,
+      message: this.message,
+      code: this.code,
+      userFacing: this.userFacing,
+      retryable: this.retryable,
+      metadata: {
+        ...this.metadata,
+        errorName: this.name,
+        ...this.cause && {
+          causeName: this.cause.name,
+          causeMessage: this.cause.message
+        }
+      }
+    };
+  }
+  /**
+   * Serialize for logging/transmission.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      source: this.source,
+      code: this.code,
+      severity: this.severity,
+      retryable: this.retryable,
+      userFacing: this.userFacing,
+      metadata: this.metadata,
+      stack: this.stack,
+      cause: this.cause ? { name: this.cause.name, message: this.cause.message } : void 0
+    };
+  }
+  /**
+   * Create from an unknown error.
+   */
+  static fromUnknown(error, source = "unknown") {
+    if (error instanceof _TerminalsError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      return new _TerminalsError(error.message, {
+        source,
+        code: ErrorCodes.UNKNOWN_ERROR,
+        severity: "error",
+        cause: error
+      });
+    }
+    return new _TerminalsError(String(error), {
+      source,
+      code: ErrorCodes.UNKNOWN_ERROR,
+      severity: "error"
+    });
+  }
+};
+var SyncError = class extends TerminalsError {
+  constructor(message, code = ErrorCodes.SYNC_FAILED, metadata) {
+    super(message, {
+      source: "sync",
+      code,
+      severity: code === ErrorCodes.SYNC_CONFLICT ? "warn" : "error",
+      retryable: code !== ErrorCodes.SYNC_CONFLICT,
+      userFacing: code === ErrorCodes.SYNC_OFFLINE,
+      metadata
+    });
+  }
+};
+var MCPError = class extends TerminalsError {
+  constructor(message, code = ErrorCodes.MCP_CONNECTION_FAILED, metadata) {
+    super(message, {
+      source: "mcp",
+      code,
+      severity: code === ErrorCodes.MCP_SERVER_UNAVAILABLE ? "warn" : "error",
+      retryable: code !== ErrorCodes.MCP_TOOL_EXECUTION_FAILED,
+      userFacing: true,
+      metadata
+    });
+  }
+};
+var WebContainerError = class extends TerminalsError {
+  constructor(message, code = ErrorCodes.WEBCONTAINER_BOOT_FAILED, metadata) {
+    super(message, {
+      source: "webcontainer",
+      code,
+      severity: code === ErrorCodes.WEBCONTAINER_NOT_SUPPORTED ? "info" : "error",
+      retryable: code === ErrorCodes.WEBCONTAINER_BOOT_FAILED,
+      userFacing: true,
+      metadata
+    });
+  }
+};
+
+export {
+  ErrorCodes,
+  SyncError,
+  MCPError,
+  WebContainerError
+};

package/dist/chunk-PPFTKJDB.js

@@ -0,0 +1,497 @@
+import {
+  BASE_PHASE_LOCKING_VALUE_NODE_ID,
+  BASE_RESONANCE_IQ_ENCODE_NODE_ID,
+  BASE_RESONANCE_IQ_PHASE_SHIFT_NODE_ID,
+  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,
+  executeHvmProofEdgeCheck,
+  executeIqEncode,
+  executeIqPhaseShift,
+  executePhaseLockingValueNode,
+  executeProviderChat,
+  executeResonanceMetrics,
+  executeSystemSchedule,
+  executeSystemSignalEmit
+} from "./chunk-KASHT6C5.js";
+
+// ../../lib/types/safe-types.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+
+// ../../lib/terminals-tech/machines/core/runners/registry.ts
+var RunnerRegistry = class {
+  workerRunners = /* @__PURE__ */ new Map();
+  // key: manifest id
+  tierRunners = /* @__PURE__ */ new Map();
+  // key: tier name
+  /**
+   * Register a worker runner for a specific node manifest ID.
+   *
+   * @param manifestId - Node manifest ID (e.g., 'http-fetch')
+   * @param fn - Worker runner function
+   */
+  registerWorker(manifestId, fn) {
+    this.workerRunners.set(manifestId, fn);
+  }
+  /**
+   * Retrieve a registered worker runner by manifest ID.
+   *
+   * @param manifestId - Node manifest ID
+   * @returns Worker runner function or null if not found
+   */
+  getWorker(manifestId) {
+    return this.workerRunners.get(manifestId) || null;
+  }
+  /**
+   * Register a generic runner for a runtime tier.
+   *
+   * @param tier - Runtime tier name (e.g., 'stack', 'webcontainer')
+   * @param fn - Runner function for that tier
+   */
+  registerRunner(tier, fn) {
+    this.tierRunners.set(tier, fn);
+  }
+  /**
+   * Retrieve a registered runner for a runtime tier.
+   *
+   * @param tier - Runtime tier name
+   * @returns Runner function or null if not found
+   */
+  getRunner(tier) {
+    return this.tierRunners.get(tier) || null;
+  }
+};
+var runners = new RunnerRegistry();
+import("./demo-T655Z5S4.js").catch((err) => console.warn("[RunnerRegistry] demo runner import failed", err));
+import("./stack-4KWCQQP7.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 || {};
+  try {
+    const { decrypt } = await import("./crypto-D4LMI2RN.js");
+    const { resolveSecretValue } = await import("./secret-store-H7273UIT.js");
+    const outSecrets = {};
+    for (const [k, v] of Object.entries(secrets)) {
+      try {
+        const parsed = JSON.parse(String(v));
+        if (isObject(parsed) && "iv" in parsed && "ct" in parsed) {
+          outSecrets[k] = decrypt(parsed);
+        } else {
+          outSecrets[k] = String(v);
+        }
+      } catch {
+        outSecrets[k] = String(v);
+      }
+    }
+    const { __secrets: _secrets, ...clean } = typedInput;
+    const out = await executeProviderChat(
+      clean,
+      {
+        getSecret: async (ref) => {
+          if (ref) {
+            const value = await resolveSecretValue(ref, {
+              ownerId: ctx.userId || "anonymous",
+              stackId: ctx.stackId,
+              nodeId: ctx.nodeId,
+              appletId: ctx.appletId,
+              worldId: ctx.worldId,
+              terminalId: ctx.terminalId
+            });
+            if (value) {
+              const resolved = typeof value === "string" ? value : "";
+              return { ...outSecrets, [ref]: resolved, apiKey: resolved };
+            }
+          }
+          return outSecrets;
+        }
+      }
+    );
+    return out;
+  } catch {
+    const { __secrets: _secrets, ...clean } = typedInput;
+    const out = await executeProviderChat(
+      clean,
+      {
+        getSecret: async (ref) => {
+          const secretsRecord = {};
+          if (isObject(secrets)) {
+            for (const [key, val] of Object.entries(secrets)) {
+              secretsRecord[key] = isString(val) ? val : String(val ?? "");
+            }
+          }
+          if (ref) {
+            const secretValue = isObject(secrets) ? secrets[ref] : void 0;
+            return {
+              ...secretsRecord,
+              [ref]: isString(secretValue) ? secretValue : String(secretValue ?? "")
+            };
+          }
+          return secretsRecord;
+        }
+      }
+    );
+    return out;
+  }
+});
+runners.registerWorker("base.time.timeline.v1", async (_m, input) => {
+  const mod = await import("./core-H2UUDATO.js");
+  const windowVal = isObject(input) && "window" in input && isString(input.window) ? input.window : void 0;
+  const tl = mod.makeTimeline(windowVal);
+  const eventsVal = isObject(input) && "events" in input ? input.events : void 0;
+  const events = isArray(eventsVal) ? eventsVal : [];
+  return tl.process(events);
+});
+runners.registerWorker(SYSTEM_SCHEDULE_NODE_ID, async (_m, input, ctx) => {
+  return await executeSystemSchedule(input, { stackId: ctx.stackId });
+});
+runners.registerWorker(HVM_PROOF_EDGE_CHECK_NODE_ID, async (_m, input, ctx) => {
+  return await executeHvmProofEdgeCheck(input, {
+    stackId: ctx.stackId,
+    nodeId: ctx.nodeId
+  });
+});
+runners.registerWorker(COMPUTE_BEND_NODE_ID, async (_m, input, ctx) => {
+  return await executeBendCompute(input, {
+    stackId: ctx.stackId,
+    nodeId: ctx.nodeId
+  });
+});
+runners.registerWorker(SYSTEM_SIGNAL_EMIT_NODE_ID, async (_m, input, ctx) => {
+  return await executeSystemSignalEmit(input, {
+    stackId: ctx.stackId,
+    nodeId: ctx.nodeId
+  });
+});
+runners.registerWorker(BASE_RESONANCE_IQ_ENCODE_NODE_ID, async (_m, input) => {
+  return await executeIqEncode(input);
+});
+runners.registerWorker(BASE_RESONANCE_IQ_PHASE_SHIFT_NODE_ID, async (_m, input) => {
+  return await executeIqPhaseShift(input);
+});
+runners.registerWorker(BASE_RESONANCE_METRICS_NODE_ID, async (_m, input) => {
+  return await executeResonanceMetrics(input);
+});
+runners.registerWorker(BASE_PHASE_LOCKING_VALUE_NODE_ID, async (_m, input) => {
+  return await executePhaseLockingValueNode(input);
+});
+runners.registerWorker("base.time.memory.v1", async (_m, input) => {
+  const mod = await import("./core-H2UUDATO.js");
+  return mod.temporalKV().handle(input);
+});
+runners.registerWorker("base.field.store3d.v1", async (_m, input) => {
+  const mod = await import("./core-H2UUDATO.js");
+  return mod.fieldStore3d().handle(input);
+});
+runners.registerWorker("base.field.projector.v1", async (_m, input) => {
+  const emb = await import("./embeddings-MAEWWUHW.js");
+  const pointsVal = isObject(input) && "points" in input ? input.points : void 0;
+  const points = isArray(pointsVal) ? pointsVal.filter(
+    (point) => isObject(point) && typeof point.x === "number" && typeof point.y === "number" && typeof point.z === "number"
+  ) : [];
+  const modelVal = isObject(input) && "model" in input ? input.model : void 0;
+  const model = isString(modelVal) ? modelVal : "default";
+  const embeddings = await emb.encodePoints(points, { model });
+  return { embeddings };
+});
+runners.registerWorker("base.semantic.zero-agent.v1", async (_m, input) => {
+  const mod = await import("./core-H2UUDATO.js");
+  return mod.zeroAgent().handle(input);
+});
+runners.registerWorker("base.semantic.entity-graph.v1", async (_m, input) => {
+  const g = await import("./graph-RKMNE2X5.js");
+  return g.entityGraph().handle(input);
+});
+runners.registerWorker("base.interface.oracle-adapter.v1", async (_m, input, ctx) => {
+  const mod = await import("./core-H2UUDATO.js");
+  return mod.httpOracle(ctx?.policies).handle(input);
+});
+runners.registerWorker("astro.transform.buildAgentPrompt.v1", async (_m, input) => {
+  const questionVal = isObject(input) && "question" in input ? input.question : void 0;
+  const q = String(questionVal || "");
+  const product = isObject(input) && "product" in input ? input.product : null;
+  const record = isObject(input) && "record" in input ? input.record : null;
+  const lines = [];
+  if (product) lines.push(`Context (product): ${JSON.stringify(product).slice(0, 2e3)}`);
+  if (record) lines.push(`Context (record): ${JSON.stringify(record).slice(0, 2e3)}`);
+  const prompt = `${lines.join("\n")}
+
+Question: ${q}
+Answer with observed facts first, then suggested follow-ups and uncertainties.`;
+  return { prompt };
+});
+runners.registerWorker("transform.object.pickPath.v1", async (_m, input) => {
+  const objVal = isObject(input) && "object" in input ? input.object : void 0;
+  const obj = isObject(objVal) ? objVal : {};
+  const pathVal = isObject(input) && "path" in input ? input.path : void 0;
+  const path = String(pathVal || "");
+  const segs = path.split(".").filter(Boolean);
+  let cur = obj;
+  for (const s of segs) {
+    if (isObject(cur) && s in cur) {
+      cur = cur[s];
+    } else {
+      cur = void 0;
+      break;
+    }
+  }
+  return { value: cur };
+});
+if (!runners.getWorker("provider.http.invoke.v1")) {
+  runners.registerWorker("provider.http.invoke.v1", async (_m, input, ctx) => {
+    const { isNetworkAllowed, requireNetworkApproval } = await import("./policy-IRJCM6FS.js");
+    const urlVal = isObject(input) && "url" in input ? input.url : void 0;
+    const url = String(urlVal || "");
+    const methodVal = isObject(input) && "method" in input ? input.method : void 0;
+    const method = String(methodVal || "GET").toUpperCase();
+    const headersVal = isObject(input) && "headers" in input ? input.headers : void 0;
+    const headers = isObject(headersVal) ? headersVal : {};
+    const body = isObject(input) && "body" in input ? input.body : void 0;
+    const parseVal = isObject(input) && "parse" in input ? input.parse : void 0;
+    const parse = String(parseVal || "json");
+    if (!(isNetworkAllowed(ctx?.policies, url) || await requireNetworkApproval(ctx.stackId, ctx.nodeId, ctx?.policies, url))) {
+      throw new Error("egress not allowed (approval required)");
+    }
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const text = await res.text();
+    if (!res.ok) throw new Error(`http ${res.status}: ${text.slice(0, 256)}`);
+    try {
+      return parse === "json" ? JSON.parse(text) : { text };
+    } catch {
+      return { text };
+    }
+  });
+}
+if (!runners.getWorker("items.pickPreferred.v1")) {
+  runners.registerWorker("items.pickPreferred.v1", async (_m, input) => {
+    const itemsVal = isObject(input) && "items" in input ? input.items : void 0;
+    const items = isArray(itemsVal) ? itemsVal : [];
+    const preferVal = isObject(input) && "prefer" in input ? input.prefer : void 0;
+    const prefer = isArray(preferVal) ? preferVal : [];
+    const typeKeyVal = isObject(input) && "typeKey" in input ? input.typeKey : void 0;
+    const typeKey = String(typeKeyVal || "type");
+    const groupKeyVal = isObject(input) && "groupKey" in input ? input.groupKey : void 0;
+    const groupKey = String(groupKeyVal || "group");
+    const key = (p) => {
+      if (isObject(p) && typeKey in p) {
+        return String(p[typeKey] || "").toLowerCase();
+      }
+      return "";
+    };
+    const groups = /* @__PURE__ */ new Map();
+    for (const p of items) {
+      const id = isObject(p) && groupKey in p ? String(p[groupKey] ?? "group") : "group";
+      const arr = groups.get(id) || [];
+      arr.push(p);
+      groups.set(id, arr);
+    }
+    const selected = [];
+    for (const [, arr] of groups.entries()) {
+      let pick = null;
+      for (const t of prefer) {
+        pick = arr.find((p) => key(p).includes(String(t).toLowerCase()));
+        if (pick) break;
+      }
+      pick = pick || arr[0];
+      if (pick) selected.push(pick);
+    }
+    return { selected };
+  });
+}
+if (!runners.getWorker("transform.buildPrompt.v1")) {
+  runners.registerWorker("transform.buildPrompt.v1", async (_m, input) => {
+    const questionVal = isObject(input) && "question" in input ? input.question : void 0;
+    const q = String(questionVal || "");
+    const ctxVal = isObject(input) && "context" in input ? input.context : void 0;
+    const ctx = isObject(ctxVal) ? ctxVal : {};
+    const preview = JSON.stringify(ctx).slice(0, 2e3);
+    const prompt = `Context: ${preview}
+
+Question: ${q}
+Answer with observed facts first, then follow-ups and uncertainties.`;
+    return { prompt };
+  });
+}
+if (!runners.getWorker("intel.embedText.v1")) {
+  runners.registerWorker("intel.embedText.v1", async (_m, input) => {
+    const { encodeTextBatch } = await import("./embeddings-MAEWWUHW.js");
+    const textVal = isObject(input) && "text" in input ? input.text : void 0;
+    const text = String(textVal || "");
+    const [vec] = await encodeTextBatch([text]);
+    return { vector: vec };
+  });
+}
+runners.registerWorker("intel.llm.http.v1", async (_m, input, ctx) => {
+  const { isNetworkAllowed, requireNetworkApproval } = await import("./policy-IRJCM6FS.js");
+  const typedInput = input;
+  const promptVal = isObject(input) && "prompt" in input ? input.prompt : void 0;
+  const prompt = String(promptVal || "");
+  const modelVal = isObject(input) && "model" in input ? input.model : void 0;
+  const model = String(modelVal || "openrouter/auto");
+  const apiKeyVal = isObject(input) && "apiKey" in input ? input.apiKey : void 0;
+  const secretsApiKey = isObject(typedInput.__secrets) ? typedInput.__secrets.OPENROUTER_API_KEY : void 0;
+  let apiKey = String(apiKeyVal || (isString(secretsApiKey) ? secretsApiKey : "") || "");
+  if (!apiKey) {
+    try {
+      const { resolveSecretValue } = await import("./secret-store-H7273UIT.js");
+      const value = await resolveSecretValue("OPENROUTER_API_KEY", {
+        ownerId: ctx.userId || "anonymous",
+        stackId: ctx.stackId,
+        nodeId: ctx.nodeId,
+        appletId: ctx.appletId,
+        worldId: ctx.worldId,
+        terminalId: ctx.terminalId
+      });
+      if (value) apiKey = value;
+    } catch {
+    }
+  }
+  const url = "https://openrouter.ai/api/v1/chat/completions";
+  if (!(isNetworkAllowed(ctx?.policies, url) || await requireNetworkApproval(ctx.stackId, ctx.nodeId, ctx?.policies, url))) {
+    throw new Error("egress not allowed (approval required)");
+  }
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+    },
+    body: JSON.stringify({
+      model,
+      messages: [{ role: "user", content: prompt }],
+      stream: false
+    })
+  });
+  const json = await res.json().catch(() => ({ error: "failed to parse" }));
+  if (!res.ok) throw new Error(json?.error || `llm http ${res.status}`);
+  const text = json?.choices?.[0]?.message?.content || "";
+  return {
+    text,
+    messages: json?.choices?.[0]?.messages || [{ role: "assistant", content: text }]
+  };
+});
+runners.registerWorker("integration.source.poll.v1", async (_m, input, ctx) => {
+  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;
+  const resource = String(resourceVal || "");
+  const configVal = isObject(input) && "config" in input ? input.config : void 0;
+  const config = isObject(configVal) ? configVal : {};
+  const cursorKeyVal = isObject(input) && "cursorKey" in input ? input.cursorKey : void 0;
+  const cursorKey = String(cursorKeyVal || `${providerId}:${resource}`);
+  const prov = getProvider(providerId);
+  if (!prov?.integration) throw new Error(`provider not found: ${providerId}`);
+  const secrets = {};
+  try {
+    const { resolveSecretValue } = await import("./secret-store-H7273UIT.js");
+    const names = ["DISCORD_BOT_TOKEN"];
+    for (const n of names) {
+      const value = await resolveSecretValue(n, {
+        ownerId: ctx.userId || "anonymous",
+        stackId: ctx.stackId,
+        nodeId: ctx.nodeId,
+        appletId: ctx.appletId,
+        worldId: ctx.worldId,
+        terminalId: ctx.terminalId
+      });
+      if (value) secrets[n] = value;
+    }
+  } catch {
+  }
+  const mem = (await import("./core-H2UUDATO.js")).temporalKV();
+  const cur = await mem.handle({ get: { key: cursorKey } });
+  const cursor = cur?.value ? String(cur.value) : void 0;
+  const req = prov.integration.buildRequest("poll", { resource, config, cursor }, secrets);
+  const { isNetworkAllowed, requireNetworkApproval } = await import("./policy-IRJCM6FS.js");
+  if (!(isNetworkAllowed(ctx?.policies, req.url) || await requireNetworkApproval(ctx.stackId, ctx.nodeId, ctx?.policies, req.url))) {
+    throw new Error("egress not allowed (approval required)");
+  }
+  const res = await fetch(req.url, {
+    method: req.method,
+    headers: req.headers
+  });
+  const text = await res.text();
+  const raw = req.parse === "json" ? JSON.parse(text) : text;
+  const items = prov.integration.toEnvelope(raw, resource);
+  const nextCursor = prov.integration.extractCursor && prov.integration.extractCursor(raw, cursor) || cursor || null;
+  if (nextCursor && nextCursor !== cursor)
+    await mem.handle({ put: { key: cursorKey, value: nextCursor } });
+  return { items, cursor: nextCursor };
+});
+runners.registerWorker("integration.sink.post.v1", async (_m, input, ctx) => {
+  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;
+  const resource = String(resourceVal || "");
+  const configVal = isObject(input) && "config" in input ? input.config : void 0;
+  const config = isObject(configVal) ? configVal : {};
+  const singleItem = isObject(input) && "item" in input ? input.item : void 0;
+  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 = getProvider(providerId);
+  if (!prov?.integration) throw new Error(`provider not found: ${providerId}`);
+  const secrets = {};
+  try {
+    const { resolveSecretValue } = await import("./secret-store-H7273UIT.js");
+    const names = ["DISCORD_BOT_TOKEN"];
+    for (const n of names) {
+      const value = await resolveSecretValue(n, {
+        ownerId: ctx.userId || "anonymous",
+        stackId: ctx.stackId,
+        nodeId: ctx.nodeId,
+        appletId: ctx.appletId,
+        worldId: ctx.worldId,
+        terminalId: ctx.terminalId
+      });
+      if (value) secrets[n] = value;
+    }
+  } catch {
+  }
+  const { isNetworkAllowed, requireNetworkApproval } = await import("./policy-IRJCM6FS.js");
+  let lastStatus = 0;
+  let allOk = true;
+  for (const it of items) {
+    const itemPayload = isObject(it) ? it : { value: it };
+    const req = prov.integration.buildRequest(
+      "post",
+      { resource, config, item: itemPayload },
+      secrets
+    );
+    if (!(isNetworkAllowed(ctx?.policies, req.url) || await requireNetworkApproval(ctx.stackId, ctx.nodeId, ctx?.policies, req.url))) {
+      throw new Error("egress not allowed (approval required)");
+    }
+    const res = await fetch(req.url, {
+      method: req.method,
+      headers: req.headers,
+      body: req.body ? JSON.stringify(req.body) : void 0
+    });
+    lastStatus = res.status;
+    allOk = allOk && res.ok;
+  }
+  if (items.length === 0) {
+    return { ok: true, status: 204 };
+  }
+  return { ok: allOk, status: lastStatus };
+});
+
+export {
+  runners
+};