@kiwa-test/edge 1.0.2 → 1.1.0

package/dist/index.cjs

@@ -20,8 +20,45 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AXIS_TO_EVENTS: () => AXIS_TO_EVENTS,
+  acceptWebSocket: () => acceptWebSocket,
+  closeStream: () => closeStream,
+  closeWebSocket: () => closeWebSocket,
+  collectFidelityCoverage: () => collectFidelityCoverage,
+  completeCpu: () => completeCpu,
+  completeCron: () => completeCron,
+  completeSubrequest: () => completeSubrequest,
+  countSubrequest: () => countSubrequest,
+  createDurableObject: () => createDurableObject,
+  createEdgeKvSession: () => createEdgeKvSession,
+  createGeoReplicatedSession: () => createGeoReplicatedSession,
   createKvNamespace: () => createKvNamespace,
-  invokeEdgeHandler: () => invokeEdgeHandler
+  failCron: () => failCron,
+  fireAlarm: () => fireAlarm,
+  geoPrimaryWrite: () => geoPrimaryWrite,
+  invokeEdgeHandler: () => invokeEdgeHandler,
+  kvRangeQuery: () => kvRangeQuery,
+  kvRead: () => kvRead,
+  kvWrite: () => kvWrite,
+  markReplicaLagged: () => markReplicaLagged,
+  openStream: () => openStream,
+  platformEventName: () => platformEventName,
+  remainingBudget: () => remainingBudget,
+  requestDurableObject: () => requestDurableObject,
+  requestWebSocketUpgrade: () => requestWebSocketUpgrade,
+  resolveConflict: () => resolveConflict,
+  resumeStream: () => resumeStream,
+  scheduleCron: () => scheduleCron,
+  sendChunk: () => sendChunk,
+  sendMessage: () => sendMessage,
+  startCpu: () => startCpu,
+  startCpuBudget: () => startCpuBudget,
+  startCron: () => startCron,
+  startSubrequest: () => startSubrequest,
+  startSubrequestBudget: () => startSubrequestBudget,
+  syncReplica: () => syncReplica,
+  tickCpu: () => tickCpu,
+  writeStorage: () => writeStorage
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -126,9 +163,836 @@ function createKvNamespace(initial = {}) {
     }
   };
 }
+
+// src/semantics/types.ts
+var dialect = {
+  cloudflare: {
+    "durable-object.created": "durable_object.created",
+    "durable-object.requested": "durable_object.fetch",
+    "durable-object.alarm-fired": "durable_object.alarm",
+    "durable-object.storage-written": "durable_object.storage.put",
+    "websocket.upgrade-requested": "websocket_upgrade.requested",
+    "websocket.accepted": "websocket_upgrade.accepted",
+    "websocket.message": "websocket.message",
+    "websocket.closed": "websocket.close",
+    "kv.read": "kv_get",
+    "kv.write": "kv_put",
+    "kv.cache-hit": "kv_cache.hit",
+    "kv.cache-miss": "kv_cache.miss",
+    "geo.primary-write": "smart_placement.primary_write",
+    "geo.replica-lagged": "kv_replication.lagged",
+    "geo.replica-synced": "kv_replication.synced",
+    "geo.conflict-resolved": "durable_object.conflict_resolved",
+    "cron.scheduled": "scheduled_event.enqueued",
+    "cron.started": "scheduled_event.started",
+    "cron.completed": "scheduled_event.completed",
+    "cron.failed": "scheduled_event.failed",
+    "subrequest.started": "subrequest.fetch",
+    "subrequest.counted": "subrequest.counted",
+    "subrequest.limited": "subrequest.limit_exceeded",
+    "subrequest.completed": "subrequest.completed",
+    "cpu.started": "worker.cpu.started",
+    "cpu.budget-warning": "worker.cpu.warning",
+    "cpu.limited": "worker.cpu.limit_exceeded",
+    "cpu.completed": "worker.cpu.completed",
+    "stream.opened": "response_stream.opened",
+    "stream.chunk-sent": "response_stream.chunk",
+    "stream.backpressure": "response_stream.backpressure",
+    "stream.closed": "response_stream.closed"
+  },
+  vercel: {
+    "durable-object.created": "edge_function.session_affinity.created",
+    "durable-object.requested": "edge_function.session_affinity.request",
+    "durable-object.alarm-fired": "edge_function.background_timer",
+    "durable-object.storage-written": "edge_config.write",
+    "websocket.upgrade-requested": "edge_websocket_upgrade.requested",
+    "websocket.accepted": "edge_websocket_upgrade.accepted",
+    "websocket.message": "edge_websocket.message",
+    "websocket.closed": "edge_websocket.close",
+    "kv.read": "edge_config.get",
+    "kv.write": "edge_config.set",
+    "kv.cache-hit": "edge_config.cache_hit",
+    "kv.cache-miss": "edge_config.cache_miss",
+    "geo.primary-write": "edge_config.primary_write",
+    "geo.replica-lagged": "edge_config.replica_lagged",
+    "geo.replica-synced": "edge_config.replica_synced",
+    "geo.conflict-resolved": "edge_config.conflict_resolved",
+    "cron.scheduled": "vercel_cron.scheduled",
+    "cron.started": "vercel_cron.started",
+    "cron.completed": "vercel_cron.completed",
+    "cron.failed": "vercel_cron.failed",
+    "subrequest.started": "edge_function.fetch",
+    "subrequest.counted": "edge_function.subrequest_counted",
+    "subrequest.limited": "edge_function.subrequest_limited",
+    "subrequest.completed": "edge_function.fetch_completed",
+    "cpu.started": "edge_function.cpu_started",
+    "cpu.budget-warning": "edge_function.cpu_warning",
+    "cpu.limited": "edge_function.cpu_limited",
+    "cpu.completed": "edge_function.cpu_completed",
+    "stream.opened": "edge_function.stream_opened",
+    "stream.chunk-sent": "edge_function.stream_chunk",
+    "stream.backpressure": "edge_function.stream_backpressure",
+    "stream.closed": "edge_function.stream_closed"
+  },
+  deno: {
+    "durable-object.created": "deploy.stateful_object.created",
+    "durable-object.requested": "deploy.stateful_fetch",
+    "durable-object.alarm-fired": "deploy.cron.timer",
+    "durable-object.storage-written": "deno_kv.atomic_write",
+    "websocket.upgrade-requested": "deno_websocket_upgrade.requested",
+    "websocket.accepted": "deno_websocket_upgrade.accepted",
+    "websocket.message": "deno_websocket.message",
+    "websocket.closed": "deno_websocket.close",
+    "kv.read": "deno_kv.get",
+    "kv.write": "deno_kv.set",
+    "kv.cache-hit": "deno_kv.cache_hit",
+    "kv.cache-miss": "deno_kv.cache_miss",
+    "geo.primary-write": "deno_kv.primary_write",
+    "geo.replica-lagged": "deno_kv.replica_lagged",
+    "geo.replica-synced": "deno_kv.replica_synced",
+    "geo.conflict-resolved": "deno_kv.conflict_resolved",
+    "cron.scheduled": "deploy.cron.scheduled",
+    "cron.started": "deploy.cron.started",
+    "cron.completed": "deploy.cron.completed",
+    "cron.failed": "deploy.cron.failed",
+    "subrequest.started": "deploy.fetch.started",
+    "subrequest.counted": "deploy.fetch.counted",
+    "subrequest.limited": "deploy.fetch.limited",
+    "subrequest.completed": "deploy.fetch.completed",
+    "cpu.started": "deploy.cpu.started",
+    "cpu.budget-warning": "deploy.cpu.warning",
+    "cpu.limited": "deploy.cpu.limited",
+    "cpu.completed": "deploy.cpu.completed",
+    "stream.opened": "deploy.stream.opened",
+    "stream.chunk-sent": "deploy.stream.chunk",
+    "stream.backpressure": "deploy.stream.backpressure",
+    "stream.closed": "deploy.stream.closed"
+  }
+};
+function platformEventName(platform, neutral) {
+  return dialect[platform][neutral] ?? neutral;
+}
+
+// src/semantics/fidelity.ts
+var AXIS_TO_EVENTS = {
+  "durable-object": [
+    "durable-object.created",
+    "durable-object.requested",
+    "durable-object.alarm-fired",
+    "durable-object.storage-written"
+  ],
+  "websocket-edge": [
+    "websocket.upgrade-requested",
+    "websocket.accepted",
+    "websocket.message",
+    "websocket.closed"
+  ],
+  "edge-kv": ["kv.read", "kv.write", "kv.cache-hit", "kv.cache-miss"],
+  "geo-replicated": [
+    "geo.primary-write",
+    "geo.replica-lagged",
+    "geo.replica-synced",
+    "geo.conflict-resolved"
+  ],
+  "cron-trigger": ["cron.scheduled", "cron.started", "cron.completed", "cron.failed"],
+  "subrequest-limit": [
+    "subrequest.started",
+    "subrequest.counted",
+    "subrequest.limited",
+    "subrequest.completed"
+  ],
+  "cpu-time-limit": ["cpu.started", "cpu.budget-warning", "cpu.limited", "cpu.completed"],
+  "streaming-response": [
+    "stream.opened",
+    "stream.chunk-sent",
+    "stream.backpressure",
+    "stream.closed"
+  ]
+};
+function collectFidelityCoverage(platforms) {
+  const axes = Object.keys(AXIS_TO_EVENTS);
+  const rows = [];
+  for (const platform of platforms) {
+    for (const axis of axes) {
+      const neutralEvents = AXIS_TO_EVENTS[axis];
+      const platformEvents = neutralEvents.map((n) => platformEventName(platform, n));
+      rows.push({
+        platform,
+        axis,
+        neutralEvents,
+        platformEvents
+      });
+    }
+  }
+  return { platforms, axes, rows };
+}
+
+// src/semantics/durable-object.ts
+function record(session, step) {
+  session.history.push(step);
+  return step;
+}
+function createDurableObject(input) {
+  const session = {
+    id: input.id,
+    platform: input.platform,
+    state: "initialized",
+    requestCount: 0,
+    storageKeys: /* @__PURE__ */ new Map(),
+    scheduledAlarmAt: null,
+    history: []
+  };
+  record(session, {
+    neutralEvent: "durable-object.created",
+    platformEvent: platformEventName(input.platform, "durable-object.created"),
+    state: "initialized",
+    platform: input.platform,
+    metadata: { id: input.id }
+  });
+  return session;
+}
+function requestDurableObject(session, input) {
+  if (session.state === "terminated") {
+    throw new Error("requestDurableObject: object is terminated");
+  }
+  session.state = "active";
+  session.requestCount += 1;
+  return record(session, {
+    neutralEvent: "durable-object.requested",
+    platformEvent: platformEventName(session.platform, "durable-object.requested"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { url: input.url, requestCount: session.requestCount }
+  });
+}
+function fireAlarm(session) {
+  if (session.state === "terminated") {
+    throw new Error("fireAlarm: object is terminated");
+  }
+  const firedAt = session.scheduledAlarmAt;
+  session.scheduledAlarmAt = null;
+  session.state = "active";
+  return record(session, {
+    neutralEvent: "durable-object.alarm-fired",
+    platformEvent: platformEventName(session.platform, "durable-object.alarm-fired"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { firedAt: firedAt ?? 0, scheduled: firedAt !== null }
+  });
+}
+function writeStorage(session, input) {
+  if (session.state === "terminated") {
+    throw new Error("writeStorage: object is terminated");
+  }
+  session.storageKeys.set(input.key, input.value);
+  session.state = "active";
+  return record(session, {
+    neutralEvent: "durable-object.storage-written",
+    platformEvent: platformEventName(session.platform, "durable-object.storage-written"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { key: input.key, size: input.value.length, keyCount: session.storageKeys.size }
+  });
+}
+
+// src/semantics/websocket-edge.ts
+function record2(session, step) {
+  session.history.push(step);
+  return step;
+}
+function requestWebSocketUpgrade(input) {
+  const session = {
+    id: input.id,
+    platform: input.platform,
+    state: "pending",
+    messages: [],
+    history: []
+  };
+  record2(session, {
+    neutralEvent: "websocket.upgrade-requested",
+    platformEvent: platformEventName(input.platform, "websocket.upgrade-requested"),
+    state: "pending",
+    platform: input.platform,
+    metadata: { id: input.id }
+  });
+  return session;
+}
+function acceptWebSocket(session) {
+  if (session.state !== "pending") {
+    throw new Error(`acceptWebSocket: socket is ${session.state}, expected pending`);
+  }
+  session.state = "open";
+  return record2(session, {
+    neutralEvent: "websocket.accepted",
+    platformEvent: platformEventName(session.platform, "websocket.accepted"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { id: session.id }
+  });
+}
+function sendMessage(session, input) {
+  if (session.state !== "open") {
+    throw new Error(`sendMessage: socket is ${session.state}, expected open`);
+  }
+  session.messages.push(input.data);
+  return record2(session, {
+    neutralEvent: "websocket.message",
+    platformEvent: platformEventName(session.platform, "websocket.message"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { size: input.data.length, index: session.messages.length - 1 }
+  });
+}
+function closeWebSocket(session, input) {
+  if (session.state === "closed") {
+    throw new Error("closeWebSocket: socket already closed");
+  }
+  session.state = "closed";
+  return record2(session, {
+    neutralEvent: "websocket.closed",
+    platformEvent: platformEventName(session.platform, "websocket.closed"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { code: input.code, totalMessages: session.messages.length }
+  });
+}
+
+// src/semantics/edge-kv.ts
+function record3(session, step) {
+  session.history.push(step);
+  return step;
+}
+function createEdgeKvSession(input) {
+  return {
+    platform: input.platform,
+    store: /* @__PURE__ */ new Map(),
+    cache: /* @__PURE__ */ new Map(),
+    state: input.state ?? "eventually-consistent",
+    history: []
+  };
+}
+function kvRead(session, input) {
+  let neutral;
+  let hit;
+  if (session.cache.has(input.key)) {
+    neutral = "kv.cache-hit";
+    hit = true;
+  } else if (session.store.has(input.key)) {
+    session.cache.set(input.key, session.store.get(input.key));
+    neutral = "kv.read";
+    hit = false;
+  } else {
+    neutral = "kv.cache-miss";
+    hit = false;
+  }
+  return record3(session, {
+    neutralEvent: neutral,
+    platformEvent: platformEventName(session.platform, neutral),
+    state: session.state,
+    platform: session.platform,
+    metadata: { key: input.key, hit }
+  });
+}
+function kvWrite(session, input) {
+  session.store.set(input.key, input.value);
+  session.cache.delete(input.key);
+  return record3(session, {
+    neutralEvent: "kv.write",
+    platformEvent: platformEventName(session.platform, "kv.write"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { key: input.key, size: input.value.length }
+  });
+}
+function kvRangeQuery(session, input) {
+  const limit = input.limit ?? Number.POSITIVE_INFINITY;
+  const matches = [...session.store.keys()].filter((k) => k.startsWith(input.prefix)).sort().slice(0, limit);
+  const step = record3(session, {
+    neutralEvent: "kv.read",
+    platformEvent: platformEventName(session.platform, "kv.read"),
+    state: session.state,
+    platform: session.platform,
+    metadata: {
+      prefix: input.prefix,
+      matched: matches.length,
+      limit: Number.isFinite(limit) ? limit : 0
+    }
+  });
+  return { matches, step };
+}
+
+// src/semantics/geo-replicated.ts
+var POST_WRITE_LAG_MS = 100;
+function record4(session, step) {
+  session.history.push(step);
+  return step;
+}
+function createGeoReplicatedSession(input) {
+  const lagMs = {};
+  for (const region of input.replicaRegions) lagMs[region] = 0;
+  return {
+    platform: input.platform,
+    primaryRegion: input.primaryRegion,
+    replicaRegions: [...input.replicaRegions],
+    state: "in-sync",
+    version: 0,
+    lagMs,
+    history: []
+  };
+}
+function geoPrimaryWrite(session, input) {
+  session.version += 1;
+  session.state = "lagging";
+  for (const region of session.replicaRegions) session.lagMs[region] = POST_WRITE_LAG_MS;
+  return record4(session, {
+    neutralEvent: "geo.primary-write",
+    platformEvent: platformEventName(session.platform, "geo.primary-write"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { version: session.version, region: session.primaryRegion, size: input.data.length }
+  });
+}
+function markReplicaLagged(session, input) {
+  if (!session.replicaRegions.includes(input.region)) {
+    throw new Error(`markReplicaLagged: ${input.region} is not a replica region`);
+  }
+  session.lagMs[input.region] = input.lagMs;
+  session.state = "lagging";
+  return record4(session, {
+    neutralEvent: "geo.replica-lagged",
+    platformEvent: platformEventName(session.platform, "geo.replica-lagged"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { region: input.region, lagMs: input.lagMs }
+  });
+}
+function syncReplica(session, input) {
+  if (!session.replicaRegions.includes(input.region)) {
+    throw new Error(`syncReplica: ${input.region} is not a replica region`);
+  }
+  session.lagMs[input.region] = 0;
+  const allSynced = session.replicaRegions.every((r) => session.lagMs[r] === 0);
+  if (allSynced) session.state = "in-sync";
+  return record4(session, {
+    neutralEvent: "geo.replica-synced",
+    platformEvent: platformEventName(session.platform, "geo.replica-synced"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { region: input.region, allSynced }
+  });
+}
+function resolveConflict(session, input) {
+  if (!session.replicaRegions.includes(input.region)) {
+    throw new Error(`resolveConflict: ${input.region} is not a replica region`);
+  }
+  session.version = input.chosenVersion;
+  for (const region of session.replicaRegions) session.lagMs[region] = 0;
+  session.state = "in-sync";
+  return record4(session, {
+    neutralEvent: "geo.conflict-resolved",
+    platformEvent: platformEventName(session.platform, "geo.conflict-resolved"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { region: input.region, chosenVersion: input.chosenVersion }
+  });
+}
+
+// src/semantics/cron-trigger.ts
+function scheduleCron(input) {
+  const triggerType = input.triggerType ?? "scheduled";
+  const maxRetries = input.maxRetries ?? 3;
+  const session = {
+    id: input.id,
+    platform: input.platform,
+    triggerType,
+    cronSpec: input.cronSpec,
+    state: "scheduled",
+    startedAt: null,
+    retryCount: 0,
+    maxRetries,
+    history: []
+  };
+  const step = {
+    neutralEvent: "cron.scheduled",
+    platformEvent: platformEventName(input.platform, "cron.scheduled"),
+    state: "scheduled",
+    platform: input.platform,
+    metadata: { triggerType, cronSpec: input.cronSpec, maxRetries }
+  };
+  session.history.push(step);
+  return session;
+}
+function startCron(session) {
+  if (session.state !== "scheduled") {
+    throw new Error(`startCron: session is ${session.state}, expected scheduled`);
+  }
+  session.state = "running";
+  session.startedAt = Date.now();
+  const step = {
+    neutralEvent: "cron.started",
+    platformEvent: platformEventName(session.platform, "cron.started"),
+    state: "running",
+    platform: session.platform,
+    metadata: { startedAt: session.startedAt, triggerType: session.triggerType }
+  };
+  session.history.push(step);
+  return step;
+}
+function completeCron(session, input) {
+  if (session.state !== "running") {
+    throw new Error(`completeCron: session is ${session.state}, expected running`);
+  }
+  session.state = "completed";
+  const step = {
+    neutralEvent: "cron.completed",
+    platformEvent: platformEventName(session.platform, "cron.completed"),
+    state: "completed",
+    platform: session.platform,
+    metadata: { durationMs: input.durationMs, triggerType: session.triggerType }
+  };
+  session.history.push(step);
+  return step;
+}
+function failCron(session, input) {
+  if (session.state !== "running") {
+    throw new Error(`failCron: session is ${session.state}, expected running`);
+  }
+  session.retryCount += 1;
+  const willRetry = session.retryCount < session.maxRetries;
+  session.state = willRetry ? "scheduled" : "failed";
+  const step = {
+    neutralEvent: "cron.failed",
+    platformEvent: platformEventName(session.platform, "cron.failed"),
+    state: session.state,
+    platform: session.platform,
+    metadata: {
+      reason: input.reason,
+      retryCount: session.retryCount,
+      willRetry,
+      triggerType: session.triggerType
+    }
+  };
+  session.history.push(step);
+  return step;
+}
+
+// src/semantics/subrequest-limit.ts
+function startSubrequestBudget(input) {
+  return {
+    platform: input.platform,
+    count: 0,
+    limit: input.limit ?? 50,
+    warningThreshold: input.warningThreshold ?? 40,
+    state: "ok",
+    history: []
+  };
+}
+function startSubrequest(session, input) {
+  if (session.state === "limited") {
+    throw new Error("startSubrequest: budget is limited, cannot start");
+  }
+  const step = {
+    neutralEvent: "subrequest.started",
+    platformEvent: platformEventName(session.platform, "subrequest.started"),
+    state: session.state,
+    platform: session.platform,
+    metadata: { url: input.url, currentCount: session.count }
+  };
+  session.history.push(step);
+  return step;
+}
+function countSubrequest(session) {
+  if (session.state === "limited") {
+    throw new Error("countSubrequest: budget is limited, cannot count further");
+  }
+  session.count += 1;
+  if (session.count >= session.limit) {
+    session.state = "limited";
+    const step2 = {
+      neutralEvent: "subrequest.limited",
+      platformEvent: platformEventName(session.platform, "subrequest.limited"),
+      state: "limited",
+      platform: session.platform,
+      metadata: { count: session.count, limit: session.limit }
+    };
+    session.history.push(step2);
+    return step2;
+  }
+  if (session.count >= session.warningThreshold) {
+    session.state = "approaching-limit";
+  }
+  const step = {
+    neutralEvent: "subrequest.counted",
+    platformEvent: platformEventName(session.platform, "subrequest.counted"),
+    state: session.state,
+    platform: session.platform,
+    metadata: {
+      count: session.count,
+      limit: session.limit,
+      remaining: session.limit - session.count
+    }
+  };
+  session.history.push(step);
+  return step;
+}
+function completeSubrequest(session, input) {
+  const step = {
+    neutralEvent: "subrequest.completed",
+    platformEvent: platformEventName(session.platform, "subrequest.completed"),
+    state: session.state,
+    platform: session.platform,
+    metadata: {
+      url: input.url,
+      durationMs: input.durationMs,
+      totalCount: session.count
+    }
+  };
+  session.history.push(step);
+  return step;
+}
+function remainingBudget(session) {
+  return Math.max(0, session.limit - session.count);
+}
+
+// src/semantics/cpu-time-limit.ts
+function startCpuBudget(input) {
+  return {
+    platform: input.platform,
+    budgetMs: input.budgetMs ?? 50,
+    warningAtMs: input.warningAtMs ?? 40,
+    elapsedMs: 0,
+    state: "idle",
+    history: []
+  };
+}
+function startCpu(session) {
+  if (session.state !== "idle") {
+    throw new Error(`startCpu: session is ${session.state}, expected idle`);
+  }
+  session.state = "running";
+  const step = {
+    neutralEvent: "cpu.started",
+    platformEvent: platformEventName(session.platform, "cpu.started"),
+    state: "running",
+    platform: session.platform,
+    metadata: { budgetMs: session.budgetMs }
+  };
+  session.history.push(step);
+  return step;
+}
+function tickCpu(session, input) {
+  if (session.state === "idle") {
+    throw new Error("tickCpu: session is idle, call startCpu first");
+  }
+  if (session.state === "throttled" || session.state === "completed") {
+    throw new Error(`tickCpu: session is ${session.state}, cannot tick`);
+  }
+  session.elapsedMs += input.deltaMs;
+  if (session.elapsedMs >= session.budgetMs) {
+    session.state = "throttled";
+    const step2 = {
+      neutralEvent: "cpu.limited",
+      platformEvent: platformEventName(session.platform, "cpu.limited"),
+      state: "throttled",
+      platform: session.platform,
+      metadata: {
+        elapsedMs: session.elapsedMs,
+        budgetMs: session.budgetMs,
+        overshootMs: session.elapsedMs - session.budgetMs
+      }
+    };
+    session.history.push(step2);
+    return step2;
+  }
+  if (session.elapsedMs >= session.warningAtMs) {
+    session.state = "warning";
+    const step2 = {
+      neutralEvent: "cpu.budget-warning",
+      platformEvent: platformEventName(session.platform, "cpu.budget-warning"),
+      state: "warning",
+      platform: session.platform,
+      metadata: {
+        elapsedMs: session.elapsedMs,
+        warningAtMs: session.warningAtMs,
+        remaining: session.budgetMs - session.elapsedMs
+      }
+    };
+    session.history.push(step2);
+    return step2;
+  }
+  const step = {
+    neutralEvent: "cpu.started",
+    platformEvent: platformEventName(session.platform, "cpu.started"),
+    state: session.state,
+    platform: session.platform,
+    metadata: {
+      elapsedMs: session.elapsedMs,
+      budgetMs: session.budgetMs,
+      remaining: session.budgetMs - session.elapsedMs
+    }
+  };
+  session.history.push(step);
+  return step;
+}
+function completeCpu(session) {
+  if (session.state === "idle") {
+    throw new Error("completeCpu: session is idle, cannot complete");
+  }
+  session.state = "completed";
+  const step = {
+    neutralEvent: "cpu.completed",
+    platformEvent: platformEventName(session.platform, "cpu.completed"),
+    state: "completed",
+    platform: session.platform,
+    metadata: {
+      elapsedMs: session.elapsedMs,
+      budgetMs: session.budgetMs,
+      usedRatio: session.elapsedMs / session.budgetMs
+    }
+  };
+  session.history.push(step);
+  return step;
+}
+
+// src/semantics/streaming-response.ts
+function openStream(input) {
+  const kind = input.kind ?? "chunked";
+  const highWaterMark = input.highWaterMark ?? 65536;
+  const session = {
+    id: input.id,
+    platform: input.platform,
+    kind,
+    state: "open",
+    chunksSent: 0,
+    bytesSent: 0,
+    highWaterMark,
+    history: []
+  };
+  const step = {
+    neutralEvent: "stream.opened",
+    platformEvent: platformEventName(input.platform, "stream.opened"),
+    state: "open",
+    platform: input.platform,
+    metadata: { id: input.id, kind, highWaterMark }
+  };
+  session.history.push(step);
+  return session;
+}
+function sendChunk(session, input) {
+  if (session.state === "closed") {
+    throw new Error("sendChunk: stream is closed");
+  }
+  session.chunksSent += 1;
+  session.bytesSent += input.data.length;
+  if (session.bytesSent > session.highWaterMark) {
+    session.state = "backpressure";
+    const step2 = {
+      neutralEvent: "stream.backpressure",
+      platformEvent: platformEventName(session.platform, "stream.backpressure"),
+      state: "backpressure",
+      platform: session.platform,
+      metadata: {
+        bytesSent: session.bytesSent,
+        highWaterMark: session.highWaterMark,
+        chunksSent: session.chunksSent
+      }
+    };
+    session.history.push(step2);
+    return step2;
+  }
+  const step = {
+    neutralEvent: "stream.chunk-sent",
+    platformEvent: platformEventName(session.platform, "stream.chunk-sent"),
+    state: session.state,
+    platform: session.platform,
+    metadata: {
+      bytesSent: session.bytesSent,
+      chunksSent: session.chunksSent,
+      size: input.data.length
+    }
+  };
+  session.history.push(step);
+  return step;
+}
+function resumeStream(session) {
+  if (session.state !== "backpressure") {
+    throw new Error(`resumeStream: stream is ${session.state}, expected backpressure`);
+  }
+  session.state = "open";
+  session.bytesSent = Math.max(0, session.bytesSent - session.highWaterMark);
+  const step = {
+    neutralEvent: "stream.chunk-sent",
+    platformEvent: platformEventName(session.platform, "stream.chunk-sent"),
+    state: "open",
+    platform: session.platform,
+    metadata: {
+      resumed: true,
+      chunksSent: session.chunksSent,
+      bytesSent: session.bytesSent
+    }
+  };
+  session.history.push(step);
+  return step;
+}
+function closeStream(session, input) {
+  if (session.state === "closed") {
+    throw new Error("closeStream: stream already closed");
+  }
+  session.state = "closed";
+  const step = {
+    neutralEvent: "stream.closed",
+    platformEvent: platformEventName(session.platform, "stream.closed"),
+    state: "closed",
+    platform: session.platform,
+    metadata: {
+      reason: input.reason,
+      totalChunks: session.chunksSent,
+      totalBytes: session.bytesSent
+    }
+  };
+  session.history.push(step);
+  return step;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AXIS_TO_EVENTS,
+  acceptWebSocket,
+  closeStream,
+  closeWebSocket,
+  collectFidelityCoverage,
+  completeCpu,
+  completeCron,
+  completeSubrequest,
+  countSubrequest,
+  createDurableObject,
+  createEdgeKvSession,
+  createGeoReplicatedSession,
   createKvNamespace,
-  invokeEdgeHandler
+  failCron,
+  fireAlarm,
+  geoPrimaryWrite,
+  invokeEdgeHandler,
+  kvRangeQuery,
+  kvRead,
+  kvWrite,
+  markReplicaLagged,
+  openStream,
+  platformEventName,
+  remainingBudget,
+  requestDurableObject,
+  requestWebSocketUpgrade,
+  resolveConflict,
+  resumeStream,
+  scheduleCron,
+  sendChunk,
+  sendMessage,
+  startCpu,
+  startCpuBudget,
+  startCron,
+  startSubrequest,
+  startSubrequestBudget,
+  syncReplica,
+  tickCpu,
+  writeStorage
 });
 //# sourceMappingURL=index.cjs.map