@standardagents/builder 0.41.7 → 0.41.9

package/dist/runtime.js

@@ -1,6 +1,6 @@
 import { getProviderModelPricing } from '@standardagents/provider-pricing';
 import { jsonPathReader } from '@formkit/jsonreader';
-import { ProviderError, mapReasoningLevel, validateAgentDefinition, THREAD_STREAM_REASONING_PARAM, isUserEndpoint } from '@standardagents/spec';
+import { ProviderError, mapReasoningLevel, validateAgentDefinition, THREAD_STREAM_REASONING_PARAM, isUserRoom, isUserEndpoint } from '@standardagents/spec';
 export { HANDLER_SYMBOL, ProviderError, belongsToPackage, defineAgent, defineHandler, defineHook, defineModel, definePrompt, defineProvider, defineTool, isHandler, isPacked, isVisibleInNamespace, mapReasoningLevel, providerConst, providerEnv, providerValue } from '@standardagents/spec';
 import 'virtual:@standardagents-providers';
 import { DurableObject, WorkerEntrypoint } from 'cloudflare:workers';
@@ -30198,6 +30198,41 @@ function canAccessThread(auth, thread) {
   return thread.user_id === auth.user.id;
 }
 
+// src/users/upstream-timing.ts
+var UPSTREAM_TIMING_HEADER = "x-standard-upstream-timing";
+var MAX_HEADER_CHARS = 512;
+function formatUpstreamTiming(name, durationMs) {
+  const safe = Number.isFinite(durationMs) && durationMs > 0 ? durationMs : 0;
+  return `${name};dur=${Math.round(safe * 10) / 10}`;
+}
+function appendUpstreamTiming(current, name, durationMs) {
+  const entry = formatUpstreamTiming(name, durationMs);
+  if (!current) return entry;
+  const combined = `${current}, ${entry}`;
+  return combined.length > MAX_HEADER_CHARS ? current : combined;
+}
+function withUpstreamTiming(request, value) {
+  const headers = new Headers(request.headers);
+  headers.set(UPSTREAM_TIMING_HEADER, value);
+  return new Request(request, { headers });
+}
+function responseWithUpstreamTiming(response, name, durationMs) {
+  if (response.status === 101) return response;
+  const value = appendUpstreamTiming(response.headers.get(UPSTREAM_TIMING_HEADER), name, durationMs);
+  try {
+    response.headers.set(UPSTREAM_TIMING_HEADER, value);
+    return response;
+  } catch {
+    const headers = new Headers(response.headers);
+    headers.set(UPSTREAM_TIMING_HEADER, value);
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+}
+
 // src/runtime.ts
 init_client_forwarding();
 init_DurableThread();
@@ -30451,6 +30486,9 @@ var UserStateImpl = class {
   host;
   /** Caller descriptor for grant `allow` policy checks. */
   caller;
+  /** One identity lookup per execution: the singleton RPC runs at most once. */
+  identityLookup = null;
+  identityLookupMs = null;
   constructor(userId, host, caller) {
     this.userId = userId;
     this.host = host;
@@ -30462,6 +30500,22 @@ var UserStateImpl = class {
     return ns.get(ns.idFromName("singleton"));
   }
   async identity() {
+    if (!this.identityLookup) {
+      const started = Date.now();
+      this.identityLookup = this.lookupIdentity().finally(() => {
+        this.identityLookupMs = Date.now() - started;
+      });
+      this.identityLookup.catch(() => {
+        this.identityLookup = null;
+      });
+    }
+    return this.identityLookup;
+  }
+  /** Milliseconds the execution spent resolving identity, once it has. */
+  timing() {
+    return { identity_ms: this.identityLookupMs };
+  }
+  async lookupIdentity() {
     const user = await this.singleton().getUserById(this.userId);
     if (!user) throw new Error(`Unknown user: ${this.userId}`);
     return {
@@ -30493,6 +30547,12 @@ var UserStateImpl = class {
   emit(event, data) {
     this.host.broadcastUserEvent(this.userId, event, data);
   }
+  async clients() {
+    return this.host.listRoomClients(this.userId);
+  }
+  async send(clientId, frame) {
+    return this.host.sendToRoomClient(this.userId, clientId, frame);
+  }
   async listThreads(options) {
     const { threads, total } = await this.singleton().listThreads({
       user_id: this.userId,
@@ -30560,6 +30620,72 @@ function createExecutionChain() {
   };
 }
 
+// src/durable-objects/DurableUserHub.ts
+init_bridge_owner();
+
+// src/users/room.ts
+var ROOM_FRAME_MAX_BYTES = 1024 * 1024;
+var ROOM_FRAME_RATE_PER_SECOND = 200;
+var ROOM_FRAME_BURST = 400;
+var ROOM_SEND_BUDGET_BYTES = 8 * 1024 * 1024;
+var ROOM_SEND_BUDGET_WINDOW_MS = 1e4;
+var ROOM_PRESENCE_GRACE_MS = 3e4;
+var ROOM_CLOSE_SUPERSEDED = 4001;
+var ROOM_CLOSE_TOO_LARGE = 1009;
+var ROOM_CLOSE_TRY_AGAIN = 1013;
+function parseRoomFrame(message) {
+  const size = typeof message === "string" ? message.length : message.byteLength;
+  if (size > ROOM_FRAME_MAX_BYTES) return "too_large";
+  if (typeof message !== "string") return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(message);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const frame = parsed;
+  if (frame.type !== "room" || typeof frame.id !== "string" || frame.id.length === 0 || frame.id.length > 256) {
+    return null;
+  }
+  return frame;
+}
+var RoomRateLimiter = class {
+  constructor(ratePerSecond = ROOM_FRAME_RATE_PER_SECOND, burst = ROOM_FRAME_BURST, now = Date.now()) {
+    this.ratePerSecond = ratePerSecond;
+    this.burst = burst;
+    this.tokens = burst;
+    this.last = now;
+  }
+  tokens;
+  last;
+  take(now = Date.now()) {
+    const elapsed = Math.max(0, now - this.last) / 1e3;
+    this.tokens = Math.min(this.burst, this.tokens + elapsed * this.ratePerSecond);
+    this.last = now;
+    if (this.tokens < 1) return false;
+    this.tokens -= 1;
+    return true;
+  }
+};
+var RoomSendBudget = class {
+  constructor(budgetBytes = ROOM_SEND_BUDGET_BYTES, windowMs = ROOM_SEND_BUDGET_WINDOW_MS, now = Date.now()) {
+    this.budgetBytes = budgetBytes;
+    this.windowMs = windowMs;
+    this.windowStart = now;
+  }
+  spent = 0;
+  windowStart;
+  charge(bytes, now = Date.now()) {
+    if (now - this.windowStart >= this.windowMs) {
+      this.windowStart = now;
+      this.spent = 0;
+    }
+    this.spent += bytes;
+    return this.spent <= this.budgetBytes;
+  }
+};
+
 // src/users/grants.ts
 var INSTANCE_GRANTS_MAX_BYTES = 64 * 1024;
 var INSTANCE_GRANTS_MAX_COUNT = 64;
@@ -30715,6 +30841,12 @@ var DurableUserHub = class extends DurableObject {
   clientSockets = /* @__PURE__ */ new Set();
   clientInfo = /* @__PURE__ */ new Map();
   migrated = false;
+  /** Inbound frame rate and outbound byte budget per room socket. */
+  roomLimits = /* @__PURE__ */ new Map();
+  /** Detach notices held for the presence grace window, by client id. */
+  pendingDetach = /* @__PURE__ */ new Map();
+  /** The project's room definition, loaded once per instance. */
+  roomDefinition = null;
   constructor(ctx, env) {
     super(ctx, env);
     ctx.blockConcurrencyWhile(async () => {
@@ -30727,7 +30859,8 @@ var DurableUserHub = class extends DurableObject {
         this.clientInfo.set(ws, {
           clientId: typeof attachment.clientId === "string" ? attachment.clientId : null,
           clientName: typeof attachment.clientName === "string" ? attachment.clientName : null,
-          clientKind: typeof attachment.clientKind === "string" ? attachment.clientKind : null
+          clientKind: typeof attachment.clientKind === "string" ? attachment.clientKind : null,
+          since: typeof attachment.since === "number" ? attachment.since : void 0
         });
       }
     }
@@ -30800,24 +30933,188 @@ var DurableUserHub = class extends DurableObject {
     if (request.headers.get("Upgrade") === "websocket") {
       const pair = new WebSocketPair();
       const [client, server] = [pair[0], pair[1]];
-      const info = {
-        clientId: url.searchParams.get("client_id"),
-        clientName: url.searchParams.get("client_name"),
-        clientKind: url.searchParams.get("client_kind")
-      };
+      const info = { ...parseBridgeClientParams(url).info, since: Date.now() };
       this.ensureHeartbeatAutoResponse();
       this.ctx.acceptWebSocket(server);
       server.serializeAttachment({ type: "hub_client", ...info });
+      const reconnecting = info.clientId !== null && this.supersedeClient(info.clientId, server);
       this.clientSockets.add(server);
       this.clientInfo.set(server, info);
       try {
         server.send(JSON.stringify({ type: "hub_ready" }));
       } catch {
       }
+      if (info.clientId) {
+        const connection = this.connectionOf(info);
+        if (connection) this.observeAttach(connection, reconnecting);
+      }
       return new Response(null, { status: 101, webSocket: client });
     }
     return new Response("Not found", { status: 404 });
   }
+  // ─── Room connections (spec: Users rooms) ───────────────────────────────────
+  connectionOf(info) {
+    if (!info?.clientId) return null;
+    return { clientId: info.clientId, clientKind: info.clientKind, since: info.since ?? 0 };
+  }
+  /** Close every other socket presenting `clientId`; true when one existed. */
+  supersedeClient(clientId, keep) {
+    let superseded = false;
+    for (const ws of Array.from(this.clientSockets)) {
+      if (ws === keep || this.clientInfo.get(ws)?.clientId !== clientId) continue;
+      this.forgetSocket(ws);
+      superseded = true;
+      try {
+        ws.send(JSON.stringify({ type: "superseded" }));
+      } catch {
+      }
+      try {
+        ws.close(ROOM_CLOSE_SUPERSEDED, "Superseded by a newer connection from this client");
+      } catch {
+      }
+    }
+    return superseded;
+  }
+  forgetSocket(ws) {
+    this.clientSockets.delete(ws);
+    this.clientInfo.delete(ws);
+    this.roomLimits.delete(ws);
+  }
+  liveSocketFor(clientId) {
+    for (const ws of this.clientSockets) {
+      if (this.clientInfo.get(ws)?.clientId === clientId && ws.readyState === WebSocket.OPEN) return ws;
+    }
+    return null;
+  }
+  /** Live room connections, one per client id, oldest attachment first. */
+  listRoomClients() {
+    const byId = /* @__PURE__ */ new Map();
+    for (const ws of this.clientSockets) {
+      if (ws.readyState !== WebSocket.OPEN) continue;
+      const connection = this.connectionOf(this.clientInfo.get(ws));
+      if (connection) byId.set(connection.clientId, connection);
+    }
+    return Array.from(byId.values()).sort((a, b) => a.since - b.since);
+  }
+  /** Deliver one frame to the socket carrying `clientId`, within its send budget. */
+  sendToRoomClient(clientId, frame) {
+    const ws = this.liveSocketFor(clientId);
+    if (!ws) return false;
+    return this.sendRoomFrame(ws, JSON.stringify(frame));
+  }
+  sendRoomFrame(ws, payload) {
+    const limits = this.limitsFor(ws);
+    if (!limits.send.charge(payload.length)) {
+      this.forgetSocket(ws);
+      try {
+        ws.close(ROOM_CLOSE_TRY_AGAIN, "Slow consumer: send budget exceeded");
+      } catch {
+      }
+      return false;
+    }
+    try {
+      ws.send(payload);
+      return true;
+    } catch {
+      this.forgetSocket(ws);
+      return false;
+    }
+  }
+  limitsFor(ws) {
+    let limits = this.roomLimits.get(ws);
+    if (!limits) {
+      limits = { rate: new RoomRateLimiter(), send: new RoomSendBudget() };
+      this.roomLimits.set(ws, limits);
+    }
+    return limits;
+  }
+  /** Load the project's room definition from the users registry, once. */
+  async loadRoom() {
+    if (!this.roomDefinition) {
+      this.roomDefinition = (async () => {
+        const registry = this.userEndpoints();
+        for (const key of Object.keys(registry)) {
+          if (!/(^|\/)room$/.test(key)) continue;
+          try {
+            const loaded = await registry[key]();
+            const candidate = loaded.default ?? loaded;
+            if (isUserRoom(candidate)) return candidate;
+          } catch {
+          }
+        }
+        return null;
+      })();
+    }
+    return this.roomDefinition;
+  }
+  /** Whether `key` is room-owned state, exempt from `user_value_changed`. */
+  async roomOwnsKey(key) {
+    const room = await this.loadRoom();
+    return Boolean(room?.valuePrefix && key.startsWith(room.valuePrefix));
+  }
+  /**
+   * Presence runs inside the serialization chain, after any execution the
+   * event raced with, so a room's presence write never interleaves with a
+   * mutation. A reconnect inside the grace window is not a change.
+   */
+  observeAttach(connection, reconnecting) {
+    const pending = this.pendingDetach.get(connection.clientId);
+    if (pending) {
+      clearTimeout(pending);
+      this.pendingDetach.delete(connection.clientId);
+      return;
+    }
+    if (reconnecting) return;
+    this.dispatchRoomPresence({ kind: "attached", connection, at: Date.now() });
+  }
+  observeDetach(connection) {
+    if (this.liveSocketFor(connection.clientId)) return;
+    const existing = this.pendingDetach.get(connection.clientId);
+    if (existing) clearTimeout(existing);
+    this.pendingDetach.set(
+      connection.clientId,
+      setTimeout(() => {
+        this.pendingDetach.delete(connection.clientId);
+        if (this.liveSocketFor(connection.clientId)) return;
+        this.dispatchRoomPresence({ kind: "detached", connection, at: Date.now() });
+      }, ROOM_PRESENCE_GRACE_MS)
+    );
+  }
+  dispatchRoomPresence(event) {
+    const run = this.executionChain.run(async () => {
+      const room = await this.loadRoom();
+      if (!room?.onPresence) return;
+      const user = new UserStateImpl(this.roomUserId(), this.scopeHost(), { kind: "userRoom", name: "presence" });
+      try {
+        await room.onPresence(user, event);
+      } catch (error) {
+        console.error("[DurableUserHub] room presence handler failed:", error);
+      }
+    });
+    this.ctx.waitUntil(run);
+  }
+  /** The hub is one object per user; its name is the user id. */
+  roomUserId() {
+    return this.ctx.id.name ?? this.ctx.id.toString();
+  }
+  async dispatchRoomFrame(ws, frame) {
+    const connection = this.connectionOf(this.clientInfo.get(ws));
+    if (!connection) return;
+    await this.executionChain.run(async () => {
+      const room = await this.loadRoom();
+      if (!room) {
+        this.sendRoomFrame(ws, JSON.stringify({ type: "room", id: frame.id, error: "no_room" }));
+        return;
+      }
+      const user = new UserStateImpl(this.roomUserId(), this.scopeHost(), { kind: "userRoom", name: "frame" });
+      try {
+        await room.onFrame(user, connection, frame);
+      } catch (error) {
+        console.error("[DurableUserHub] room frame handler failed:", error);
+        this.sendRoomFrame(ws, JSON.stringify({ type: "room", id: frame.id, error: "handler_failed" }));
+      }
+    });
+  }
   // ─── User scope: event stream (spec: Users §4) ─────────────────────────────
   /** Idle sockets answer heartbeats at the edge without waking the object.
    *  Registered at accept time rather than in the constructor so a hub that
@@ -30855,8 +31152,9 @@ var DurableUserHub = class extends DurableObject {
     return new Response(null, { status: 101, webSocket: client });
   }
   /**
-   * Deliver an event frame to every socket attached to this user's stream.
-   * At-most-once, live-only (spec: Users §4) — no history, no acks.
+   * Deliver an event frame to every socket attached to this user's stream
+   * and to every room socket. At-most-once, live-only (spec: Users §4) —
+   * no history, no acks.
    */
   broadcastUserEvent(userId, event, data) {
     const frame = JSON.stringify({ event, data });
@@ -30868,6 +31166,10 @@ var DurableUserHub = class extends DurableObject {
       } catch {
       }
     }
+    for (const ws of Array.from(this.clientSockets)) {
+      if (ws.readyState !== WebSocket.OPEN || !this.clientInfo.get(ws)?.clientId) continue;
+      this.sendRoomFrame(ws, frame);
+    }
   }
   // ─── User scope: serialized endpoint execution (spec: Users §2.1, §3) ─────
   /** Per-user execution chain (spec: Users §2.1) — see users/serialize.ts. */
@@ -30878,6 +31180,8 @@ var DurableUserHub = class extends DurableObject {
       setUserValue: (userId, key, value) => this.setUserValue(userId, key, value),
       listUserValues: (userId, options) => this.listUserValues(userId, options ?? {}),
       broadcastUserEvent: (userId, event, data) => this.broadcastUserEvent(userId, event, data),
+      listRoomClients: () => this.listRoomClients(),
+      sendToRoomClient: (_userId, clientId, frame) => this.sendToRoomClient(clientId, frame),
       grantFetch: (userId, grant, req) => this.grantFetch(userId, grant, req),
       env: this.env
     };
@@ -30897,19 +31201,28 @@ var DurableUserHub = class extends DurableObject {
     }
     const module = loaded;
     const handler = module.default ?? loaded;
+    if (isUserRoom(handler)) return Response.json({ error: "Not found" }, { status: 404 });
     if (!isUserEndpoint(handler)) {
       return Response.json(
         { error: `${match.key} is not a defineUserEndpoint export` },
         { status: 500 }
       );
     }
+    const queuedAt = Date.now();
     return this.executionChain.run(async () => {
+      const queueMs = Date.now() - queuedAt;
+      const timed = withUpstreamTiming(
+        request,
+        appendUpstreamTiming(request.headers.get(UPSTREAM_TIMING_HEADER), "queue", queueMs)
+      );
       const user = new UserStateImpl(userId, this.scopeHost(), {
         kind: "userEndpoint",
         name: match.key
       });
       try {
-        return await handler.__handler(request, user, match.params);
+        const response = await handler.__handler(timed, user, match.params);
+        const identityMs = user.timing().identity_ms;
+        return identityMs === null ? response : responseWithUpstreamTiming(response, "identity", identityMs);
       } catch (error) {
         return Response.json(
           { error: error instanceof Error ? error.message : "User endpoint failed" },
@@ -30932,6 +31245,7 @@ var DurableUserHub = class extends DurableObject {
     const names = Object.keys(registry);
     if (names.length === 0) return;
     const run = async () => {
+      if (hookType === "user_value_changed" && await this.roomOwnsKey(String(args[0]))) return;
       const user = new UserStateImpl(userId, this.scopeHost(), {
         kind: "userHook",
         name: hookType
@@ -30956,6 +31270,9 @@ var DurableUserHub = class extends DurableObject {
     this.ctx.waitUntil(run());
   }
   async webSocketClose(ws) {
+    const connection = this.connectionOf(this.clientInfo.get(ws));
+    this.forgetSocket(ws);
+    if (connection) this.observeDetach(connection);
     const attachment = ws.deserializeAttachment();
     if (attachment?.type === "user_stream") {
       this.dispatchUserHooks(String(attachment.userId), "user_client_detached", [
@@ -30964,10 +31281,7 @@ var DurableUserHub = class extends DurableObject {
           kind: typeof attachment.clientKind === "string" ? attachment.clientKind : void 0
         }
       ]);
-      return;
     }
-    this.clientSockets.delete(ws);
-    this.clientInfo.delete(ws);
   }
   // ─── User scope: credential grants (spec: Users §6) ───────────────────────
   /**
@@ -31087,8 +31401,37 @@ var DurableUserHub = class extends DurableObject {
       caller: body.caller ?? { kind: "unknown", name: "unknown" }
     });
   }
-  async webSocketMessage(ws, _message) {
-    if (!this.clientSockets.has(ws)) this.clientSockets.add(ws);
+  async webSocketMessage(ws, message) {
+    const attachment = ws.deserializeAttachment();
+    if (attachment?.type !== "hub_client") return;
+    if (!this.clientSockets.has(ws)) {
+      this.clientSockets.add(ws);
+      this.clientInfo.set(ws, {
+        clientId: typeof attachment.clientId === "string" ? attachment.clientId : null,
+        clientName: typeof attachment.clientName === "string" ? attachment.clientName : null,
+        clientKind: typeof attachment.clientKind === "string" ? attachment.clientKind : null,
+        since: typeof attachment.since === "number" ? attachment.since : void 0
+      });
+    }
+    if (!this.limitsFor(ws).rate.take()) {
+      this.forgetSocket(ws);
+      try {
+        ws.close(ROOM_CLOSE_TRY_AGAIN, "Frame rate exceeded");
+      } catch {
+      }
+      return;
+    }
+    const frame = parseRoomFrame(message);
+    if (frame === "too_large") {
+      this.forgetSocket(ws);
+      try {
+        ws.close(ROOM_CLOSE_TOO_LARGE, "Frame exceeds 1 MiB");
+      } catch {
+      }
+      return;
+    }
+    if (frame === null || !this.clientInfo.get(ws)?.clientId) return;
+    await this.dispatchRoomFrame(ws, frame);
   }
   async webSocketError(ws) {
     await this.webSocketClose(ws);
@@ -31518,6 +31861,6 @@ init_ProviderRegistry();
 init_types2();
 init_resolver();
 
-export { CLIENT_STREAM_CHUNK_BYTES, CodeExecutionBridge, DurableAgentBuilder, DurableThread, DurableUserHub, FlowStateSdk, NamespaceResolutionError, ProviderRegistry, ThreadWatchdog, applyRuntimeCors, authenticate, buildImageDescription, callClient, callClientStream, canAccessThread, cat, createNamespaceContext, createThreadEndpointHandler, decodeStreamChunk, defineController2 as defineController, emitThreadEvent, encodeStreamChunk, endpointCallerFromAuth, enhanceFlowState, exists, find, forceTurn, generateImageDescription, getFileStats, getMessages, getMessagesToSummarize, getShortName, getThumbnail, getUnsummarizedImageAttachments, getVisibleAgentNames, getVisibleModelNames, getVisiblePromptNames, getVisibleToolNames, grep, hasImageAttachments, head, injectMessage, isAdminOnlyApiRoute, isHostedInstance, isPublicApiRoute, isQualifiedName, isSameOriginBrowserRequest, isTrustedLocalDevelopmentRequest, linkFile, mkdir, move, optimizeImageContext, parseQualifiedName, qualifyName, queueTool, readFile, readdir, reloadHistory, rename, replaceImagesWithDescriptions, requireAdmin, requireAuth, resolveAgent, resolveHook, resolveModel, resolvePrompt, resolveTool, rmdir, runtimeCorsHeaders, runtimePreflightResponse, stat, supportsClientForwarding, tail, unlink, updateThread, writeFile, writeImage };
+export { CLIENT_STREAM_CHUNK_BYTES, CodeExecutionBridge, DurableAgentBuilder, DurableThread, DurableUserHub, FlowStateSdk, NamespaceResolutionError, ProviderRegistry, ThreadWatchdog, applyRuntimeCors, authenticate, buildImageDescription, callClient, callClientStream, canAccessThread, cat, createNamespaceContext, createThreadEndpointHandler, decodeStreamChunk, defineController2 as defineController, emitThreadEvent, encodeStreamChunk, endpointCallerFromAuth, enhanceFlowState, exists, find, forceTurn, formatUpstreamTiming, generateImageDescription, getFileStats, getMessages, getMessagesToSummarize, getShortName, getThumbnail, getUnsummarizedImageAttachments, getVisibleAgentNames, getVisibleModelNames, getVisiblePromptNames, getVisibleToolNames, grep, hasImageAttachments, head, injectMessage, isAdminOnlyApiRoute, isHostedInstance, isPublicApiRoute, isQualifiedName, isSameOriginBrowserRequest, isTrustedLocalDevelopmentRequest, linkFile, mkdir, move, optimizeImageContext, parseQualifiedName, qualifyName, queueTool, readFile, readdir, reloadHistory, rename, replaceImagesWithDescriptions, requireAdmin, requireAuth, resolveAgent, resolveHook, resolveModel, resolvePrompt, resolveTool, rmdir, runtimeCorsHeaders, runtimePreflightResponse, stat, supportsClientForwarding, tail, unlink, updateThread, withUpstreamTiming, writeFile, writeImage };
 //# sourceMappingURL=runtime.js.map
 //# sourceMappingURL=runtime.js.map