@vibeframe/mcp-server 0.56.0 → 0.57.0

package/dist/index.js

@@ -434188,6 +434188,4268 @@ var init_grok = __esm({
   }
 });
 
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/middleware.js
+var require_middleware = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/middleware.js"(exports) {
+    "use strict";
+    var __awaiter4 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve44) {
+          resolve44(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve44, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve44(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TARGET_URL_HEADER = void 0;
+    exports.withMiddleware = withMiddleware;
+    exports.withProxy = withProxy;
+    function withMiddleware(...middlewares) {
+      const isDefined = (middleware) => typeof middleware === "function";
+      return (config4) => __awaiter4(this, void 0, void 0, function* () {
+        let currentConfig = Object.assign({}, config4);
+        for (const middleware of middlewares.filter(isDefined)) {
+          currentConfig = yield middleware(currentConfig);
+        }
+        return currentConfig;
+      });
+    }
+    exports.TARGET_URL_HEADER = "x-fal-target-url";
+    function shouldProxy(when) {
+      const env4 = {
+        isBrowser: typeof window !== "undefined" && typeof window.document !== "undefined"
+      };
+      if (typeof when === "function") {
+        return when(env4);
+      }
+      if (when === "always") {
+        return true;
+      }
+      return env4.isBrowser;
+    }
+    function withProxy(config4) {
+      return (requestConfig) => {
+        if (requestConfig.headers && exports.TARGET_URL_HEADER in requestConfig.headers) {
+          return Promise.resolve(requestConfig);
+        }
+        if (!shouldProxy(config4.when)) {
+          return Promise.resolve(requestConfig);
+        }
+        return Promise.resolve(Object.assign(Object.assign({}, requestConfig), { url: config4.targetUrl, headers: Object.assign(Object.assign({}, requestConfig.headers || {}), { [exports.TARGET_URL_HEADER]: requestConfig.url }) }));
+      };
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/headers.js
+var require_headers3 = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/headers.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RUNNER_HINT_HEADER = exports.QUEUE_PRIORITY_HEADER = exports.REQUEST_TIMEOUT_TYPE_HEADER = exports.REQUEST_TIMEOUT_HEADER = exports.MIN_REQUEST_TIMEOUT_SECONDS = void 0;
+    exports.validateTimeoutHeader = validateTimeoutHeader;
+    exports.buildTimeoutHeaders = buildTimeoutHeaders;
+    exports.MIN_REQUEST_TIMEOUT_SECONDS = 1;
+    exports.REQUEST_TIMEOUT_HEADER = "x-fal-request-timeout";
+    exports.REQUEST_TIMEOUT_TYPE_HEADER = "x-fal-request-timeout-type";
+    exports.QUEUE_PRIORITY_HEADER = "x-fal-queue-priority";
+    exports.RUNNER_HINT_HEADER = "x-fal-runner-hint";
+    function validateTimeoutHeader(timeout3) {
+      if (typeof timeout3 !== "number" || isNaN(timeout3)) {
+        throw new Error(`Timeout must be a number, got ${timeout3}`);
+      }
+      if (timeout3 <= exports.MIN_REQUEST_TIMEOUT_SECONDS) {
+        throw new Error(`Timeout must be greater than ${exports.MIN_REQUEST_TIMEOUT_SECONDS} seconds`);
+      }
+      return timeout3.toString();
+    }
+    function buildTimeoutHeaders(timeout3) {
+      if (timeout3 === void 0) {
+        return {};
+      }
+      return {
+        [exports.REQUEST_TIMEOUT_HEADER]: validateTimeoutHeader(timeout3)
+      };
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/response.js
+var require_response = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/response.js"(exports) {
+    "use strict";
+    var __awaiter4 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve44) {
+          resolve44(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve44, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve44(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ValidationError = exports.ApiError = void 0;
+    exports.defaultResponseHandler = defaultResponseHandler;
+    exports.resultResponseHandler = resultResponseHandler;
+    var headers_1 = require_headers3();
+    var REQUEST_ID_HEADER = "x-fal-request-id";
+    var ApiError = class extends Error {
+      constructor({ message, status, body, requestId, timeoutType }) {
+        super(message);
+        this.name = "ApiError";
+        this.status = status;
+        this.body = body;
+        this.requestId = requestId || "";
+        this.timeoutType = timeoutType;
+      }
+      /**
+       * Returns true if this error was caused by a user-specified timeout
+       * (via startTimeout parameter). These errors should NOT be retried.
+       */
+      get isUserTimeout() {
+        return this.status === 504 && this.timeoutType === "user";
+      }
+    };
+    exports.ApiError = ApiError;
+    var ValidationError = class extends ApiError {
+      constructor(args) {
+        super(args);
+        this.name = "ValidationError";
+      }
+      get fieldErrors() {
+        if (typeof this.body.detail === "string") {
+          return [
+            {
+              loc: ["body"],
+              msg: this.body.detail,
+              type: "value_error"
+            }
+          ];
+        }
+        return this.body.detail || [];
+      }
+      getFieldErrors(field) {
+        return this.fieldErrors.filter((error) => error.loc[error.loc.length - 1] === field);
+      }
+    };
+    exports.ValidationError = ValidationError;
+    function defaultResponseHandler(response) {
+      return __awaiter4(this, void 0, void 0, function* () {
+        var _a7;
+        const { status, statusText } = response;
+        const contentType = (_a7 = response.headers.get("Content-Type")) !== null && _a7 !== void 0 ? _a7 : "";
+        const requestId = response.headers.get(REQUEST_ID_HEADER) || void 0;
+        const timeoutType = response.headers.get(headers_1.REQUEST_TIMEOUT_TYPE_HEADER) || void 0;
+        if (!response.ok) {
+          if (contentType.includes("application/json")) {
+            const body = yield response.json();
+            const ErrorType = status === 422 ? ValidationError : ApiError;
+            throw new ErrorType({
+              message: body.message || statusText,
+              status,
+              body,
+              requestId,
+              timeoutType
+            });
+          }
+          throw new ApiError({
+            message: `HTTP ${status}: ${statusText}`,
+            status,
+            requestId,
+            timeoutType
+          });
+        }
+        if (contentType.includes("application/json")) {
+          return response.json();
+        }
+        if (contentType.includes("text/html")) {
+          return response.text();
+        }
+        if (contentType.includes("application/octet-stream")) {
+          return response.arrayBuffer();
+        }
+        return response.text();
+      });
+    }
+    function resultResponseHandler(response) {
+      return __awaiter4(this, void 0, void 0, function* () {
+        const data = yield defaultResponseHandler(response);
+        return {
+          data,
+          requestId: response.headers.get(REQUEST_ID_HEADER) || ""
+        };
+      });
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/utils.js
+var require_utils4 = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/utils.js"(exports) {
+    "use strict";
+    var __awaiter4 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve44) {
+          resolve44(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve44, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve44(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ensureEndpointIdFormat = ensureEndpointIdFormat;
+    exports.parseEndpointId = parseEndpointId;
+    exports.resolveEndpointPath = resolveEndpointPath;
+    exports.isValidUrl = isValidUrl;
+    exports.throttle = throttle;
+    exports.isReact = isReact;
+    exports.isPlainObject = isPlainObject3;
+    exports.sleep = sleep2;
+    function ensureEndpointIdFormat(id) {
+      const parts = id.split("/");
+      if (parts.length > 1) {
+        return id;
+      }
+      const [, appOwner, appId] = /^([0-9]+)-([a-zA-Z0-9-]+)$/.exec(id) || [];
+      if (appOwner && appId) {
+        return `${appOwner}/${appId}`;
+      }
+      throw new Error(`Invalid app id: ${id}. Must be in the format <appOwner>/<appId>`);
+    }
+    var ENDPOINT_NAMESPACES = ["workflows", "comfy"];
+    function parseEndpointId(id) {
+      const normalizedId = ensureEndpointIdFormat(id);
+      const parts = normalizedId.split("/");
+      if (ENDPOINT_NAMESPACES.includes(parts[0])) {
+        return {
+          owner: parts[1],
+          alias: parts[2],
+          path: parts.slice(3).join("/") || void 0,
+          namespace: parts[0]
+        };
+      }
+      return {
+        owner: parts[0],
+        alias: parts[1],
+        path: parts.slice(2).join("/") || void 0
+      };
+    }
+    function resolveEndpointPath(app, path14, defaultPath) {
+      if (path14) {
+        return `/${path14.replace(/^\/+/, "")}`;
+      }
+      if (app.endsWith(defaultPath)) {
+        return void 0;
+      }
+      return defaultPath;
+    }
+    function isValidUrl(url) {
+      try {
+        const { host } = new URL(url);
+        return /(fal\.(ai|run))$/.test(host);
+      } catch (_) {
+        return false;
+      }
+    }
+    function throttle(func, limit, leading = false) {
+      let lastFunc;
+      let lastRan;
+      return (...args) => {
+        if (!lastRan && leading) {
+          func(...args);
+          lastRan = Date.now();
+        } else {
+          if (lastFunc) {
+            clearTimeout(lastFunc);
+          }
+          lastFunc = setTimeout(() => {
+            if (Date.now() - lastRan >= limit) {
+              func(...args);
+              lastRan = Date.now();
+            }
+          }, limit - (Date.now() - lastRan));
+        }
+      };
+    }
+    var isRunningInReact;
+    function isReact() {
+      if (isRunningInReact === void 0) {
+        const stack = new Error().stack;
+        isRunningInReact = !!stack && (stack.includes("node_modules/react-dom/") || stack.includes("node_modules/next/"));
+      }
+      return isRunningInReact;
+    }
+    function isPlainObject3(value) {
+      return !!value && Object.getPrototypeOf(value) === Object.prototype;
+    }
+    function sleep2(ms) {
+      return __awaiter4(this, void 0, void 0, function* () {
+        return new Promise((resolve44) => setTimeout(resolve44, ms));
+      });
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/retry.js
+var require_retry = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/retry.js"(exports) {
+    "use strict";
+    var __awaiter4 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve44) {
+          resolve44(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve44, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve44(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DEFAULT_RETRY_OPTIONS = exports.DEFAULT_RETRYABLE_STATUS_CODES = void 0;
+    exports.isRetryableError = isRetryableError;
+    exports.calculateBackoffDelay = calculateBackoffDelay;
+    exports.executeWithRetry = executeWithRetry;
+    var response_1 = require_response();
+    var utils_1 = require_utils4();
+    exports.DEFAULT_RETRYABLE_STATUS_CODES = [429, 502, 503, 504];
+    exports.DEFAULT_RETRY_OPTIONS = {
+      maxRetries: 3,
+      baseDelay: 1e3,
+      maxDelay: 3e4,
+      backoffMultiplier: 2,
+      retryableStatusCodes: exports.DEFAULT_RETRYABLE_STATUS_CODES,
+      enableJitter: true
+    };
+    function isRetryableError(error, retryableStatusCodes) {
+      if (!(error instanceof response_1.ApiError)) {
+        return false;
+      }
+      if (error.isUserTimeout) {
+        return false;
+      }
+      return retryableStatusCodes.includes(error.status);
+    }
+    function calculateBackoffDelay(attempt, baseDelay, maxDelay, backoffMultiplier, enableJitter) {
+      const exponentialDelay = Math.min(baseDelay * Math.pow(backoffMultiplier, attempt), maxDelay);
+      if (enableJitter) {
+        const jitter = 0.25 * exponentialDelay * (Math.random() * 2 - 1);
+        return Math.max(0, exponentialDelay + jitter);
+      }
+      return exponentialDelay;
+    }
+    function executeWithRetry(operation, options, onRetry) {
+      return __awaiter4(this, void 0, void 0, function* () {
+        const metrics = {
+          totalAttempts: 0,
+          totalDelay: 0
+        };
+        let lastError;
+        for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
+          metrics.totalAttempts++;
+          try {
+            const result = yield operation();
+            return { result, metrics };
+          } catch (error) {
+            lastError = error;
+            metrics.lastError = error;
+            if (attempt === options.maxRetries || !isRetryableError(error, options.retryableStatusCodes)) {
+              throw error;
+            }
+            const delay = calculateBackoffDelay(attempt, options.baseDelay, options.maxDelay, options.backoffMultiplier, options.enableJitter);
+            metrics.totalDelay += delay;
+            if (onRetry) {
+              onRetry(attempt + 1, error, delay);
+            }
+            yield (0, utils_1.sleep)(delay);
+          }
+        }
+        throw lastError;
+      });
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/package.json
+var require_package3 = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/package.json"(exports, module) {
+    module.exports = {
+      name: "@fal-ai/client",
+      description: "The fal.ai client for JavaScript and TypeScript",
+      version: "1.10.0",
+      license: "MIT",
+      repository: {
+        type: "git",
+        url: "https://github.com/fal-ai/fal-js.git",
+        directory: "libs/client"
+      },
+      keywords: [
+        "fal",
+        "client",
+        "ai",
+        "ml",
+        "typescript"
+      ],
+      exports: {
+        ".": "./src/index.js",
+        "./endpoints": "./src/types/endpoints.js"
+      },
+      typesVersions: {
+        "*": {
+          endpoints: [
+            "src/types/endpoints.d.ts"
+          ]
+        }
+      },
+      main: "./src/index.js",
+      types: "./src/index.d.ts",
+      dependencies: {
+        "@msgpack/msgpack": "^3.0.0-beta2",
+        "eventsource-parser": "^1.1.2",
+        robot3: "^0.4.1"
+      },
+      engines: {
+        node: ">=18.0.0"
+      },
+      type: "commonjs"
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/runtime.js
+var require_runtime3 = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/runtime.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isBrowser = isBrowser;
+    exports.getUserAgent = getUserAgent;
+    function isBrowser() {
+      return typeof window !== "undefined" && typeof window.document !== "undefined";
+    }
+    var memoizedUserAgent = null;
+    function getUserAgent() {
+      if (memoizedUserAgent !== null) {
+        return memoizedUserAgent;
+      }
+      const packageInfo = require_package3();
+      memoizedUserAgent = `${packageInfo.name}/${packageInfo.version}`;
+      return memoizedUserAgent;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/config.js
+var require_config = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/config.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.credentialsFromEnv = void 0;
+    exports.resolveDefaultFetch = resolveDefaultFetch;
+    exports.createConfig = createConfig;
+    exports.getRestApiUrl = getRestApiUrl;
+    var middleware_1 = require_middleware();
+    var response_1 = require_response();
+    var retry_1 = require_retry();
+    var runtime_1 = require_runtime3();
+    function resolveDefaultFetch() {
+      if (typeof fetch === "undefined") {
+        throw new Error("Your environment does not support fetch. Please provide your own fetch implementation.");
+      }
+      return fetch;
+    }
+    function hasEnvVariables() {
+      return typeof process !== "undefined" && process.env && (typeof process.env.FAL_KEY !== "undefined" || typeof process.env.FAL_KEY_ID !== "undefined" && typeof process.env.FAL_KEY_SECRET !== "undefined");
+    }
+    var credentialsFromEnv = () => {
+      if (!hasEnvVariables()) {
+        return void 0;
+      }
+      if (typeof process.env.FAL_KEY !== "undefined") {
+        return process.env.FAL_KEY;
+      }
+      return process.env.FAL_KEY_ID ? `${process.env.FAL_KEY_ID}:${process.env.FAL_KEY_SECRET}` : void 0;
+    };
+    exports.credentialsFromEnv = credentialsFromEnv;
+    var DEFAULT_CONFIG2 = {
+      credentials: exports.credentialsFromEnv,
+      suppressLocalCredentialsWarning: false,
+      requestMiddleware: (request5) => Promise.resolve(request5),
+      responseHandler: response_1.defaultResponseHandler,
+      retry: retry_1.DEFAULT_RETRY_OPTIONS
+    };
+    function createConfig(config4) {
+      var _a7;
+      let configuration2 = Object.assign(Object.assign(Object.assign({}, DEFAULT_CONFIG2), config4), {
+        fetch: (_a7 = config4.fetch) !== null && _a7 !== void 0 ? _a7 : resolveDefaultFetch(),
+        // Merge retry configuration with defaults
+        retry: Object.assign(Object.assign({}, retry_1.DEFAULT_RETRY_OPTIONS), config4.retry || {})
+      });
+      if (config4.proxyUrl) {
+        const proxy = typeof config4.proxyUrl === "string" ? { url: config4.proxyUrl } : config4.proxyUrl;
+        configuration2 = Object.assign(Object.assign({}, configuration2), { requestMiddleware: (0, middleware_1.withMiddleware)(configuration2.requestMiddleware, (0, middleware_1.withProxy)({ targetUrl: proxy.url, when: proxy.when })) });
+      }
+      const { credentials: resolveCredentials, suppressLocalCredentialsWarning } = configuration2;
+      const credentials = typeof resolveCredentials === "function" ? resolveCredentials() : resolveCredentials;
+      if ((0, runtime_1.isBrowser)() && credentials && !suppressLocalCredentialsWarning) {
+        console.warn("The fal credentials are exposed in the browser's environment. That's not recommended for production use cases.");
+      }
+      return configuration2;
+    }
+    function getRestApiUrl() {
+      return "https://rest.fal.ai";
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/request.js
+var require_request = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/request.js"(exports) {
+    "use strict";
+    var __awaiter4 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve44) {
+          resolve44(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve44, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve44(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __rest3 = exports && exports.__rest || function(s, e) {
+      var t = {};
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+      if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+            t[p[i]] = s[p[i]];
+        }
+      return t;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.dispatchRequest = dispatchRequest;
+    exports.buildUrl = buildUrl;
+    var retry_1 = require_retry();
+    var runtime_1 = require_runtime3();
+    var utils_1 = require_utils4();
+    var isCloudflareWorkers = typeof navigator !== "undefined" && (navigator === null || navigator === void 0 ? void 0 : navigator.userAgent) === "Cloudflare-Workers";
+    function dispatchRequest(params) {
+      return __awaiter4(this, void 0, void 0, function* () {
+        var _a7;
+        const { targetUrl, input: input3, config: config4, options = {} } = params;
+        const { credentials: credentialsValue, requestMiddleware, responseHandler, fetch: fetch3 } = config4;
+        const retryOptions = Object.assign(Object.assign({}, config4.retry), options.retry || {});
+        const executeRequest = () => __awaiter4(this, void 0, void 0, function* () {
+          var _a8, _b3, _c3;
+          const userAgent = (0, runtime_1.isBrowser)() ? {} : { "User-Agent": (0, runtime_1.getUserAgent)() };
+          const credentials = typeof credentialsValue === "function" ? credentialsValue() : credentialsValue;
+          const { method, url, headers } = yield requestMiddleware({
+            method: ((_b3 = (_a8 = params.method) !== null && _a8 !== void 0 ? _a8 : options.method) !== null && _b3 !== void 0 ? _b3 : "post").toUpperCase(),
+            url: targetUrl,
+            headers: params.headers
+          });
+          const authHeader = credentials ? { Authorization: `Key ${credentials}` } : {};
+          const requestHeaders = Object.assign(Object.assign(Object.assign(Object.assign({}, authHeader), { Accept: "application/json", "Content-Type": "application/json" }), userAgent), headers !== null && headers !== void 0 ? headers : {});
+          const { responseHandler: customResponseHandler, retry: _ } = options, requestInit = __rest3(options, ["responseHandler", "retry"]);
+          const response = yield fetch3(url, Object.assign(Object.assign(Object.assign(Object.assign({}, requestInit), { method, headers: Object.assign(Object.assign({}, requestHeaders), (_c3 = requestInit.headers) !== null && _c3 !== void 0 ? _c3 : {}) }), !isCloudflareWorkers && { mode: "cors" }), { signal: options.signal, body: method.toLowerCase() !== "get" && input3 ? JSON.stringify(input3) : void 0 }));
+          const handleResponse = customResponseHandler !== null && customResponseHandler !== void 0 ? customResponseHandler : responseHandler;
+          return yield handleResponse(response);
+        });
+        let lastError;
+        for (let attempt = 0; attempt <= retryOptions.maxRetries; attempt++) {
+          try {
+            return yield executeRequest();
+          } catch (error) {
+            lastError = error;
+            const shouldNotRetry = attempt === retryOptions.maxRetries || !(0, retry_1.isRetryableError)(error, retryOptions.retryableStatusCodes) || ((_a7 = options.signal) === null || _a7 === void 0 ? void 0 : _a7.aborted);
+            if (shouldNotRetry) {
+              throw error;
+            }
+            const delay = (0, retry_1.calculateBackoffDelay)(attempt, retryOptions.baseDelay, retryOptions.maxDelay, retryOptions.backoffMultiplier, retryOptions.enableJitter);
+            yield (0, utils_1.sleep)(delay);
+          }
+        }
+        throw lastError;
+      });
+    }
+    function buildUrl(id, options = {}) {
+      var _a7, _b3;
+      const method = ((_a7 = options.method) !== null && _a7 !== void 0 ? _a7 : "post").toLowerCase();
+      const path14 = ((_b3 = options.path) !== null && _b3 !== void 0 ? _b3 : "").replace(/^\//, "").replace(/\/{2,}/, "/");
+      const input3 = options.input;
+      const params = Object.assign(Object.assign({}, options.query || {}), method === "get" ? input3 : {});
+      const queryParams = Object.keys(params).length > 0 ? `?${new URLSearchParams(params).toString()}` : "";
+      if ((0, utils_1.isValidUrl)(id)) {
+        const url2 = id.endsWith("/") ? id : `${id}/`;
+        return `${url2}${path14}${queryParams}`;
+      }
+      const appId = (0, utils_1.ensureEndpointIdFormat)(id);
+      const subdomain = options.subdomain ? `${options.subdomain}.` : "";
+      const url = `https://${subdomain}fal.run/${appId}/${path14}`;
+      return `${url.replace(/\/$/, "")}${queryParams}`;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/storage.js
+var require_storage = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/storage.js"(exports) {
+    "use strict";
+    var __awaiter4 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve44) {
+          resolve44(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve44, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve44(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OBJECT_LIFECYCYLE_PREFERENCE_HEADER = void 0;
+    exports.getExpirationDurationSeconds = getExpirationDurationSeconds;
+    exports.buildObjectLifecycleHeaders = buildObjectLifecycleHeaders;
+    exports.createStorageClient = createStorageClient;
+    var config_1 = require_config();
+    var request_1 = require_request();
+    var utils_1 = require_utils4();
+    exports.OBJECT_LIFECYCYLE_PREFERENCE_HEADER = "x-fal-object-lifecycle-preference";
+    var EXPIRATION_VALUES = {
+      never: void 0,
+      immediate: 60,
+      "1h": 3600,
+      "1d": 86400,
+      "7d": 604800,
+      "30d": 2592e3,
+      "1y": 31536e3
+    };
+    function getExpirationDurationSeconds(lifecycle) {
+      const { expiresIn } = lifecycle;
+      if (expiresIn === void 0) {
+        return void 0;
+      }
+      return typeof expiresIn === "number" ? expiresIn : EXPIRATION_VALUES[expiresIn];
+    }
+    function buildUploadLifecycleConfig(lifecycle) {
+      if (!lifecycle) {
+        return void 0;
+      }
+      const expirationDurationSeconds = getExpirationDurationSeconds(lifecycle);
+      const lifecycleConfig = {};
+      if (expirationDurationSeconds !== void 0) {
+        lifecycleConfig.expiration_duration_seconds = expirationDurationSeconds;
+      }
+      if (lifecycle.initialAcl !== void 0) {
+        lifecycleConfig.initial_acl = lifecycle.initialAcl;
+      }
+      return Object.keys(lifecycleConfig).length > 0 ? lifecycleConfig : void 0;
+    }
+    function buildObjectLifecycleHeaders(lifecycle) {
+      const lifecycleConfig = buildUploadLifecycleConfig(lifecycle);
+      if (!lifecycleConfig) {
+        return {};
+      }
+      return {
+        [exports.OBJECT_LIFECYCYLE_PREFERENCE_HEADER]: JSON.stringify(lifecycleConfig)
+      };
+    }
+    function getExtensionFromContentType(contentType) {
+      var _a7;
+      const [, fileType] = contentType.split("/");
+      return (_a7 = fileType.split(/[-;]/)[0]) !== null && _a7 !== void 0 ? _a7 : "bin";
+    }
+    function initiateUpload(file, config4, contentType, lifecycle) {
+      return __awaiter4(this, void 0, void 0, function* () {
+        const filename = file.name || `${Date.now()}.${getExtensionFromContentType(contentType)}`;
+        const headers = {};
+        const lifecycleConfig = buildUploadLifecycleConfig(lifecycle);
+        if (lifecycleConfig) {
+          headers["X-Fal-Object-Lifecycle"] = JSON.stringify(lifecycleConfig);
+        }
+        return yield (0, request_1.dispatchRequest)({
+          method: "POST",
+          // NOTE: We want to test V3 without making it the default at the API level
+          targetUrl: `${(0, config_1.getRestApiUrl)()}/storage/upload/initiate?storage_type=fal-cdn-v3`,
+          input: {
+            content_type: contentType,
+            file_name: filename
+          },
+          config: config4,
+          headers
+        });
+      });
+    }
+    function initiateMultipartUpload(file, config4, contentType, lifecycle) {
+      return __awaiter4(this, void 0, void 0, function* () {
+        const filename = file.name || `${Date.now()}.${getExtensionFromContentType(contentType)}`;
+        const headers = {};
+        const lifecycleConfig = buildUploadLifecycleConfig(lifecycle);
+        if (lifecycleConfig) {
+          headers["X-Fal-Object-Lifecycle"] = JSON.stringify(lifecycleConfig);
+        }
+        return yield (0, request_1.dispatchRequest)({
+          method: "POST",
+          targetUrl: `${(0, config_1.getRestApiUrl)()}/storage/upload/initiate-multipart?storage_type=fal-cdn-v3`,
+          input: {
+            content_type: contentType,
+            file_name: filename
+          },
+          config: config4,
+          headers
+        });
+      });
+    }
+    function partUploadRetries(uploadUrl_1, chunk_1, config_2) {
+      return __awaiter4(this, arguments, void 0, function* (uploadUrl, chunk, config4, tries = 3) {
+        if (tries === 0) {
+          throw new Error("Part upload failed, retries exhausted");
+        }
+        const { fetch: fetch3, responseHandler } = config4;
+        try {
+          const response = yield fetch3(uploadUrl, {
+            method: "PUT",
+            body: chunk
+          });
+          return yield responseHandler(response);
+        } catch (error) {
+          return yield partUploadRetries(uploadUrl, chunk, config4, tries - 1);
+        }
+      });
+    }
+    function multipartUpload(file, config4, lifecycle) {
+      return __awaiter4(this, void 0, void 0, function* () {
+        const { fetch: fetch3, responseHandler } = config4;
+        const contentType = file.type || "application/octet-stream";
+        const { upload_url: uploadUrl, file_url: url } = yield initiateMultipartUpload(file, config4, contentType, lifecycle);
+        const chunkSize = 10 * 1024 * 1024;
+        const chunks = Math.ceil(file.size / chunkSize);
+        const parsedUrl = new URL(uploadUrl);
+        const responses = [];
+        for (let i = 0; i < chunks; i++) {
+          const start = i * chunkSize;
+          const end = Math.min(start + chunkSize, file.size);
+          const chunk = file.slice(start, end);
+          const partNumber = i + 1;
+          const partUploadUrl = `${parsedUrl.origin}${parsedUrl.pathname}/${partNumber}${parsedUrl.search}`;
+          responses.push(yield partUploadRetries(partUploadUrl, chunk, config4));
+        }
+        const completeUrl = `${parsedUrl.origin}${parsedUrl.pathname}/complete${parsedUrl.search}`;
+        const response = yield fetch3(completeUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            parts: responses.map((mpart) => ({
+              partNumber: mpart.partNumber,
+              etag: mpart.etag
+            }))
+          })
+        });
+        yield responseHandler(response);
+        return url;
+      });
+    }
+    function createStorageClient({ config: config4 }) {
+      const ref = {
+        upload: (file, options) => __awaiter4(this, void 0, void 0, function* () {
+          const lifecycle = options === null || options === void 0 ? void 0 : options.lifecycle;
+          if (file.size > 90 * 1024 * 1024) {
+            return yield multipartUpload(file, config4, lifecycle);
+          }
+          const contentType = file.type || "application/octet-stream";
+          const { fetch: fetch3, responseHandler } = config4;
+          const { upload_url: uploadUrl, file_url: url } = yield initiateUpload(file, config4, contentType, lifecycle);
+          const response = yield fetch3(uploadUrl, {
+            method: "PUT",
+            body: file,
+            headers: {
+              "Content-Type": file.type || "application/octet-stream"
+            }
+          });
+          yield responseHandler(response);
+          return url;
+        }),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        transformInput: (input3) => __awaiter4(this, void 0, void 0, function* () {
+          if (Array.isArray(input3)) {
+            return Promise.all(input3.map((item) => ref.transformInput(item)));
+          } else if (input3 instanceof Blob) {
+            return yield ref.upload(input3);
+          } else if ((0, utils_1.isPlainObject)(input3)) {
+            const inputObject = input3;
+            const promises = Object.entries(inputObject).map((_a7) => __awaiter4(this, [_a7], void 0, function* ([key2, value]) {
+              return [key2, yield ref.transformInput(value)];
+            }));
+            const results = yield Promise.all(promises);
+            return Object.fromEntries(results);
+          }
+          return input3;
+        })
+      };
+      return ref;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/eventsource-parser@1.1.2/node_modules/eventsource-parser/dist/index.cjs
+var require_dist14 = __commonJS({
+  "../../node_modules/.pnpm/eventsource-parser@1.1.2/node_modules/eventsource-parser/dist/index.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function createParser(onParse) {
+      let isFirstChunk;
+      let buffer;
+      let startingPosition;
+      let startingFieldLength;
+      let eventId;
+      let eventName;
+      let data;
+      reset();
+      return {
+        feed,
+        reset
+      };
+      function reset() {
+        isFirstChunk = true;
+        buffer = "";
+        startingPosition = 0;
+        startingFieldLength = -1;
+        eventId = void 0;
+        eventName = void 0;
+        data = "";
+      }
+      function feed(chunk) {
+        buffer = buffer ? buffer + chunk : chunk;
+        if (isFirstChunk && hasBom(buffer)) {
+          buffer = buffer.slice(BOM.length);
+        }
+        isFirstChunk = false;
+        const length = buffer.length;
+        let position = 0;
+        let discardTrailingNewline = false;
+        while (position < length) {
+          if (discardTrailingNewline) {
+            if (buffer[position] === "\n") {
+              ++position;
+            }
+            discardTrailingNewline = false;
+          }
+          let lineLength = -1;
+          let fieldLength = startingFieldLength;
+          let character;
+          for (let index = startingPosition; lineLength < 0 && index < length; ++index) {
+            character = buffer[index];
+            if (character === ":" && fieldLength < 0) {
+              fieldLength = index - position;
+            } else if (character === "\r") {
+              discardTrailingNewline = true;
+              lineLength = index - position;
+            } else if (character === "\n") {
+              lineLength = index - position;
+            }
+          }
+          if (lineLength < 0) {
+            startingPosition = length - position;
+            startingFieldLength = fieldLength;
+            break;
+          } else {
+            startingPosition = 0;
+            startingFieldLength = -1;
+          }
+          parseEventStreamLine(buffer, position, fieldLength, lineLength);
+          position += lineLength + 1;
+        }
+        if (position === length) {
+          buffer = "";
+        } else if (position > 0) {
+          buffer = buffer.slice(position);
+        }
+      }
+      function parseEventStreamLine(lineBuffer, index, fieldLength, lineLength) {
+        if (lineLength === 0) {
+          if (data.length > 0) {
+            onParse({
+              type: "event",
+              id: eventId,
+              event: eventName || void 0,
+              data: data.slice(0, -1)
+              // remove trailing newline
+            });
+            data = "";
+            eventId = void 0;
+          }
+          eventName = void 0;
+          return;
+        }
+        const noValue = fieldLength < 0;
+        const field = lineBuffer.slice(index, index + (noValue ? lineLength : fieldLength));
+        let step = 0;
+        if (noValue) {
+          step = lineLength;
+        } else if (lineBuffer[index + fieldLength + 1] === " ") {
+          step = fieldLength + 2;
+        } else {
+          step = fieldLength + 1;
+        }
+        const position = index + step;
+        const valueLength = lineLength - step;
+        const value = lineBuffer.slice(position, position + valueLength).toString();
+        if (field === "data") {
+          data += value ? "".concat(value, "\n") : "\n";
+        } else if (field === "event") {
+          eventName = value;
+        } else if (field === "id" && !value.includes("\0")) {
+          eventId = value;
+        } else if (field === "retry") {
+          const retry3 = parseInt(value, 10);
+          if (!Number.isNaN(retry3)) {
+            onParse({
+              type: "reconnect-interval",
+              value: retry3
+            });
+          }
+        }
+      }
+    }
+    var BOM = [239, 187, 191];
+    function hasBom(buffer) {
+      return BOM.every((charCode, index) => buffer.charCodeAt(index) === charCode);
+    }
+    exports.createParser = createParser;
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/auth.js
+var require_auth = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/auth.js"(exports) {
+    "use strict";
+    var __awaiter4 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve44) {
+          resolve44(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve44, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve44(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TOKEN_EXPIRATION_SECONDS = void 0;
+    exports.getTemporaryAuthToken = getTemporaryAuthToken;
+    var config_1 = require_config();
+    var request_1 = require_request();
+    var utils_1 = require_utils4();
+    exports.TOKEN_EXPIRATION_SECONDS = 120;
+    function getTemporaryAuthToken(app, config4) {
+      return __awaiter4(this, void 0, void 0, function* () {
+        const appId = (0, utils_1.parseEndpointId)(app);
+        const token = yield (0, request_1.dispatchRequest)({
+          method: "POST",
+          targetUrl: `${(0, config_1.getRestApiUrl)()}/tokens/`,
+          config: config4,
+          input: {
+            allowed_apps: [appId.alias],
+            token_expiration: exports.TOKEN_EXPIRATION_SECONDS
+          }
+        });
+        if (typeof token !== "string" && token["detail"]) {
+          return token["detail"];
+        }
+        return token;
+      });
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/streaming.js
+var require_streaming = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/streaming.js"(exports) {
+    "use strict";
+    var __awaiter4 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve44) {
+          resolve44(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve44, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve44(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __await4 = exports && exports.__await || function(v) {
+      return this instanceof __await4 ? (this.v = v, this) : new __await4(v);
+    };
+    var __asyncGenerator4 = exports && exports.__asyncGenerator || function(thisArg, _arguments, generator) {
+      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+      var g = generator.apply(thisArg, _arguments || []), i, q = [];
+      return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+        return this;
+      }, i;
+      function awaitReturn(f) {
+        return function(v) {
+          return Promise.resolve(v).then(f, reject);
+        };
+      }
+      function verb(n, f) {
+        if (g[n]) {
+          i[n] = function(v) {
+            return new Promise(function(a, b) {
+              q.push([n, v, a, b]) > 1 || resume(n, v);
+            });
+          };
+          if (f) i[n] = f(i[n]);
+        }
+      }
+      function resume(n, v) {
+        try {
+          step(g[n](v));
+        } catch (e) {
+          settle(q[0][3], e);
+        }
+      }
+      function step(r) {
+        r.value instanceof __await4 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+      }
+      function fulfill(value) {
+        resume("next", value);
+      }
+      function reject(value) {
+        resume("throw", value);
+      }
+      function settle(f, v) {
+        if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+      }
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FalStream = void 0;
+    exports.createStreamingClient = createStreamingClient;
+    var eventsource_parser_1 = require_dist14();
+    var auth_1 = require_auth();
+    var request_1 = require_request();
+    var response_1 = require_response();
+    var utils_1 = require_utils4();
+    var CONTENT_TYPE_EVENT_STREAM = "text/event-stream";
+    var EVENT_STREAM_TIMEOUT = 15 * 1e3;
+    var FalStream = class {
+      constructor(endpointId, config4, options) {
+        var _a7;
+        this.listeners = /* @__PURE__ */ new Map();
+        this.buffer = [];
+        this.currentData = void 0;
+        this.lastEventTimestamp = 0;
+        this.streamClosed = false;
+        this._requestId = null;
+        this.abortController = new AbortController();
+        this.start = () => __awaiter4(this, void 0, void 0, function* () {
+          var _a8, _b3, _c3;
+          const { endpointId: endpointId2, options: options2 } = this;
+          const { input: input3, method = "post", connectionMode = "server", tokenProvider } = options2;
+          try {
+            if (connectionMode === "client") {
+              const appId = (0, utils_1.ensureEndpointIdFormat)(endpointId2);
+              const resolvedPath = (_a8 = (0, utils_1.resolveEndpointPath)(endpointId2, void 0, "/stream")) !== null && _a8 !== void 0 ? _a8 : "";
+              const fetchToken = tokenProvider ? () => tokenProvider(`${appId}${resolvedPath}`) : () => {
+                console.warn('[fal.stream] Using the default token provider is deprecated. Please provide a `tokenProvider` function when using `connectionMode: "client"`. See https://docs.fal.ai/fal-client/authentication for more information.');
+                return (0, auth_1.getTemporaryAuthToken)(endpointId2, this.config);
+              };
+              const token = yield fetchToken();
+              const { fetch: fetch3 } = this.config;
+              const parsedUrl = new URL(this.url);
+              parsedUrl.searchParams.set("fal_jwt_token", token);
+              const response = yield fetch3(parsedUrl.toString(), {
+                method: method.toUpperCase(),
+                headers: {
+                  accept: (_b3 = options2.accept) !== null && _b3 !== void 0 ? _b3 : CONTENT_TYPE_EVENT_STREAM,
+                  "content-type": "application/json"
+                },
+                body: input3 && method !== "get" ? JSON.stringify(input3) : void 0,
+                signal: this.abortController.signal
+              });
+              this._requestId = response.headers.get("x-fal-request-id");
+              return yield this.handleResponse(response);
+            }
+            return yield (0, request_1.dispatchRequest)({
+              method: method.toUpperCase(),
+              targetUrl: this.url,
+              input: input3,
+              config: this.config,
+              options: {
+                headers: {
+                  accept: (_c3 = options2.accept) !== null && _c3 !== void 0 ? _c3 : CONTENT_TYPE_EVENT_STREAM
+                },
+                responseHandler: (response) => __awaiter4(this, void 0, void 0, function* () {
+                  this._requestId = response.headers.get("x-fal-request-id");
+                  return yield this.handleResponse(response);
+                }),
+                signal: this.abortController.signal
+              }
+            });
+          } catch (error) {
+            this.handleError(error);
+          }
+        });
+        this.handleResponse = (response) => __awaiter4(this, void 0, void 0, function* () {
+          var _a8, _b3;
+          if (!response.ok) {
+            try {
+              yield (0, response_1.defaultResponseHandler)(response);
+            } catch (error) {
+              this.emit("error", error);
+            }
+            return;
+          }
+          const body = response.body;
+          if (!body) {
+            this.emit("error", new response_1.ApiError({
+              message: "Response body is empty.",
+              status: 400,
+              body: void 0,
+              requestId: this._requestId || void 0
+            }));
+            return;
+          }
+          const isEventStream = ((_a8 = response.headers.get("content-type")) !== null && _a8 !== void 0 ? _a8 : "").startsWith(CONTENT_TYPE_EVENT_STREAM);
+          if (!isEventStream) {
+            const reader2 = body.getReader();
+            const emitRawChunk = () => {
+              reader2.read().then(({ done, value }) => {
+                if (done) {
+                  this.emit("done", this.currentData);
+                  return;
+                }
+                this.buffer.push(value);
+                this.currentData = value;
+                this.emit("data", value);
+                emitRawChunk();
+              });
+            };
+            emitRawChunk();
+            return;
+          }
+          const decoder2 = new TextDecoder("utf-8");
+          const reader = response.body.getReader();
+          const parser3 = (0, eventsource_parser_1.createParser)((event) => {
+            if (event.type === "event") {
+              const data = event.data;
+              try {
+                const parsedData = JSON.parse(data);
+                this.buffer.push(parsedData);
+                this.currentData = parsedData;
+                this.emit("data", parsedData);
+                this.emit("message", parsedData);
+              } catch (e) {
+                this.emit("error", e);
+              }
+            }
+          });
+          const timeout3 = (_b3 = this.options.timeout) !== null && _b3 !== void 0 ? _b3 : EVENT_STREAM_TIMEOUT;
+          const readPartialResponse = () => __awaiter4(this, void 0, void 0, function* () {
+            const { value, done } = yield reader.read();
+            this.lastEventTimestamp = Date.now();
+            parser3.feed(decoder2.decode(value));
+            if (Date.now() - this.lastEventTimestamp > timeout3) {
+              this.emit("error", new response_1.ApiError({
+                message: `Event stream timed out after ${(timeout3 / 1e3).toFixed(0)} seconds with no messages.`,
+                status: 408,
+                requestId: this._requestId || void 0
+              }));
+            }
+            if (!done) {
+              readPartialResponse().catch(this.handleError);
+            } else {
+              this.emit("done", this.currentData);
+            }
+          });
+          readPartialResponse().catch(this.handleError);
+          return;
+        });
+        this.handleError = (error) => {
+          var _a8;
+          if (error.name === "AbortError" || this.signal.aborted) {
+            return;
+          }
+          const apiError2 = error instanceof response_1.ApiError ? error : new response_1.ApiError({
+            message: (_a8 = error.message) !== null && _a8 !== void 0 ? _a8 : "An unknown error occurred",
+            status: 500,
+            requestId: this._requestId || void 0
+          });
+          this.emit("error", apiError2);
+          return;
+        };
+        this.on = (type, listener) => {
+          var _a8;
+          if (!this.listeners.has(type)) {
+            this.listeners.set(type, []);
+          }
+          (_a8 = this.listeners.get(type)) === null || _a8 === void 0 ? void 0 : _a8.push(listener);
+        };
+        this.emit = (type, event) => {
+          const listeners = this.listeners.get(type) || [];
+          for (const listener of listeners) {
+            listener(event);
+          }
+        };
+        this.done = () => __awaiter4(this, void 0, void 0, function* () {
+          return this.donePromise;
+        });
+        this.abort = (reason) => {
+          if (!this.streamClosed) {
+            this.abortController.abort(reason);
+          }
+        };
+        this.endpointId = endpointId;
+        this.config = config4;
+        this.url = (_a7 = options.url) !== null && _a7 !== void 0 ? _a7 : (0, request_1.buildUrl)(endpointId, {
+          path: (0, utils_1.resolveEndpointPath)(endpointId, void 0, "/stream"),
+          query: options.queryParams
+        });
+        this.options = options;
+        this.donePromise = new Promise((resolve44, reject) => {
+          if (this.streamClosed) {
+            reject(new response_1.ApiError({
+              message: "Streaming connection is already closed.",
+              status: 400,
+              body: void 0,
+              requestId: this._requestId || void 0
+            }));
+          }
+          this.signal.addEventListener("abort", () => {
+            var _a8;
+            resolve44((_a8 = this.currentData) !== null && _a8 !== void 0 ? _a8 : {});
+          });
+          this.on("done", (data) => {
+            this.streamClosed = true;
+            resolve44(data);
+          });
+          this.on("error", (error) => {
+            this.streamClosed = true;
+            reject(error);
+          });
+        });
+        if (options.signal) {
+          options.signal.addEventListener("abort", () => {
+            this.abortController.abort();
+          });
+        }
+        this.start().catch(this.handleError);
+      }
+      [Symbol.asyncIterator]() {
+        return __asyncGenerator4(this, arguments, function* _a7() {
+          let running = true;
+          const stopAsyncIterator = () => running = false;
+          this.on("error", stopAsyncIterator);
+          this.on("done", stopAsyncIterator);
+          while (running || this.buffer.length > 0) {
+            const data = this.buffer.shift();
+            if (data) {
+              yield yield __await4(data);
+            }
+            yield __await4(new Promise((resolve44) => setTimeout(resolve44, 16)));
+          }
+        });
+      }
+      /**
+       * Gets the `AbortSignal` instance that can be used to listen for abort events.
+       *
+       * **Note:** this signal is internal to the `FalStream` instance. If you pass your
+       * own abort signal, the `FalStream` will listen to it and abort it appropriately.
+       *
+       * @returns the `AbortSignal` instance.
+       * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+       */
+      get signal() {
+        return this.abortController.signal;
+      }
+      /**
+       * Gets the request id of the streaming request.
+       *
+       * @returns the request id.
+       */
+      get requestId() {
+        return this._requestId;
+      }
+    };
+    exports.FalStream = FalStream;
+    function createStreamingClient({ config: config4, storage }) {
+      return {
+        stream(endpointId, options) {
+          return __awaiter4(this, void 0, void 0, function* () {
+            const input3 = options.input ? yield storage.transformInput(options.input) : void 0;
+            return new FalStream(endpointId, config4, Object.assign(Object.assign({}, options), { input: input3 }));
+          });
+        }
+      };
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/queue.js
+var require_queue = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/queue.js"(exports) {
+    "use strict";
+    var __awaiter4 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve44) {
+          resolve44(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve44, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve44(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __rest3 = exports && exports.__rest || function(s, e) {
+      var t = {};
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+      if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+            t[p[i]] = s[p[i]];
+        }
+      return t;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createQueueClient = void 0;
+    var headers_1 = require_headers3();
+    var request_1 = require_request();
+    var response_1 = require_response();
+    var retry_1 = require_retry();
+    var storage_1 = require_storage();
+    var streaming_1 = require_streaming();
+    var utils_1 = require_utils4();
+    var DEFAULT_POLL_INTERVAL = 500;
+    var QUEUE_RETRY_CONFIG = {
+      maxRetries: 3,
+      baseDelay: 1e3,
+      maxDelay: 6e4,
+      retryableStatusCodes: retry_1.DEFAULT_RETRYABLE_STATUS_CODES
+    };
+    var QUEUE_STATUS_RETRY_CONFIG = {
+      maxRetries: 5,
+      baseDelay: 1e3,
+      maxDelay: 3e4,
+      retryableStatusCodes: [...retry_1.DEFAULT_RETRYABLE_STATUS_CODES, 500]
+    };
+    var createQueueClient = ({ config: config4, storage }) => {
+      const ref = {
+        submit(endpointId, options) {
+          return __awaiter4(this, void 0, void 0, function* () {
+            const { webhookUrl, priority, hint, startTimeout, headers, storageSettings } = options, runOptions = __rest3(options, ["webhookUrl", "priority", "hint", "startTimeout", "headers", "storageSettings"]);
+            const input3 = options.input ? yield storage.transformInput(options.input) : void 0;
+            const extraHeaders = Object.fromEntries(Object.entries(headers !== null && headers !== void 0 ? headers : {}).map(([key2, value]) => [
+              key2.toLowerCase(),
+              value
+            ]));
+            return (0, request_1.dispatchRequest)({
+              method: options.method,
+              targetUrl: (0, request_1.buildUrl)(endpointId, Object.assign(Object.assign({}, runOptions), { subdomain: "queue", query: webhookUrl ? { fal_webhook: webhookUrl } : void 0 })),
+              headers: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, extraHeaders), (0, storage_1.buildObjectLifecycleHeaders)(storageSettings)), { [headers_1.QUEUE_PRIORITY_HEADER]: priority !== null && priority !== void 0 ? priority : "normal" }), hint && { [headers_1.RUNNER_HINT_HEADER]: hint }), (0, headers_1.buildTimeoutHeaders)(startTimeout)),
+              input: input3,
+              config: config4,
+              options: {
+                signal: options.abortSignal,
+                retry: QUEUE_RETRY_CONFIG
+              }
+            });
+          });
+        },
+        status(endpointId_1, _a7) {
+          return __awaiter4(this, arguments, void 0, function* (endpointId, { requestId, logs = false, abortSignal }) {
+            const appId = (0, utils_1.parseEndpointId)(endpointId);
+            const prefix = appId.namespace ? `${appId.namespace}/` : "";
+            return (0, request_1.dispatchRequest)({
+              method: "get",
+              targetUrl: (0, request_1.buildUrl)(`${prefix}${appId.owner}/${appId.alias}`, {
+                subdomain: "queue",
+                query: { logs: logs ? "1" : "0" },
+                path: `/requests/${requestId}/status`
+              }),
+              config: config4,
+              options: {
+                signal: abortSignal,
+                retry: QUEUE_STATUS_RETRY_CONFIG
+              }
+            });
+          });
+        },
+        streamStatus(endpointId_1, _a7) {
+          return __awaiter4(this, arguments, void 0, function* (endpointId, { requestId, logs = false, connectionMode }) {
+            const appId = (0, utils_1.parseEndpointId)(endpointId);
+            const prefix = appId.namespace ? `${appId.namespace}/` : "";
+            const queryParams = {
+              logs: logs ? "1" : "0"
+            };
+            const url = (0, request_1.buildUrl)(`${prefix}${appId.owner}/${appId.alias}`, {
+              subdomain: "queue",
+              path: `/requests/${requestId}/status/stream`,
+              query: queryParams
+            });
+            return new streaming_1.FalStream(endpointId, config4, {
+              url,
+              method: "get",
+              connectionMode,
+              queryParams
+            });
+          });
+        },
+        subscribeToStatus(endpointId, options) {
+          return __awaiter4(this, void 0, void 0, function* () {
+            const requestId = options.requestId;
+            const timeout3 = options.timeout;
+            let timeoutId = void 0;
+            const handleCancelError = () => {
+            };
+            if (options.mode === "streaming") {
+              const status = yield ref.streamStatus(endpointId, {
+                requestId,
+                logs: options.logs,
+                connectionMode: "connectionMode" in options ? options.connectionMode : void 0
+              });
+              const logs = [];
+              if (timeout3) {
+                timeoutId = setTimeout(() => {
+                  status.abort();
+                  ref.cancel(endpointId, { requestId }).catch(handleCancelError);
+                  throw new Error(`Client timed out waiting for the request to complete after ${timeout3}ms`);
+                }, timeout3);
+              }
+              status.on("data", (data) => {
+                if (options.onQueueUpdate) {
+                  if ("logs" in data && Array.isArray(data.logs) && data.logs.length > 0) {
+                    logs.push(...data.logs);
+                  }
+                  options.onQueueUpdate("logs" in data ? Object.assign(Object.assign({}, data), { logs }) : data);
+                }
+              });
+              const doneStatus = yield status.done();
+              if (timeoutId) {
+                clearTimeout(timeoutId);
+              }
+              return doneStatus;
+            }
+            return new Promise((resolve44, reject) => {
+              var _a7;
+              let pollingTimeoutId;
+              const pollInterval = "pollInterval" in options && typeof options.pollInterval === "number" ? (_a7 = options.pollInterval) !== null && _a7 !== void 0 ? _a7 : DEFAULT_POLL_INTERVAL : DEFAULT_POLL_INTERVAL;
+              const clearScheduledTasks = () => {
+                if (timeoutId) {
+                  clearTimeout(timeoutId);
+                }
+                if (pollingTimeoutId) {
+                  clearTimeout(pollingTimeoutId);
+                }
+              };
+              if (timeout3) {
+                timeoutId = setTimeout(() => {
+                  clearScheduledTasks();
+                  ref.cancel(endpointId, { requestId }).catch(handleCancelError);
+                  reject(new Error(`Client timed out waiting for the request to complete after ${timeout3}ms`));
+                }, timeout3);
+              }
+              const poll = () => __awaiter4(this, void 0, void 0, function* () {
+                var _a8;
+                try {
+                  const requestStatus = yield ref.status(endpointId, {
+                    requestId,
+                    logs: (_a8 = options.logs) !== null && _a8 !== void 0 ? _a8 : false,
+                    abortSignal: options.abortSignal
+                  });
+                  if (options.onQueueUpdate) {
+                    options.onQueueUpdate(requestStatus);
+                  }
+                  if (requestStatus.status === "COMPLETED") {
+                    clearScheduledTasks();
+                    resolve44(requestStatus);
+                    return;
+                  }
+                  pollingTimeoutId = setTimeout(poll, pollInterval);
+                } catch (error) {
+                  clearScheduledTasks();
+                  reject(error);
+                }
+              });
+              poll().catch(reject);
+            });
+          });
+        },
+        result(endpointId_1, _a7) {
+          return __awaiter4(this, arguments, void 0, function* (endpointId, { requestId, abortSignal }) {
+            const appId = (0, utils_1.parseEndpointId)(endpointId);
+            const prefix = appId.namespace ? `${appId.namespace}/` : "";
+            return (0, request_1.dispatchRequest)({
+              method: "get",
+              targetUrl: (0, request_1.buildUrl)(`${prefix}${appId.owner}/${appId.alias}`, {
+                subdomain: "queue",
+                path: `/requests/${requestId}`
+              }),
+              config: Object.assign(Object.assign({}, config4), { responseHandler: response_1.resultResponseHandler }),
+              options: {
+                signal: abortSignal,
+                retry: QUEUE_RETRY_CONFIG
+              }
+            });
+          });
+        },
+        cancel(endpointId_1, _a7) {
+          return __awaiter4(this, arguments, void 0, function* (endpointId, { requestId, abortSignal }) {
+            const appId = (0, utils_1.parseEndpointId)(endpointId);
+            const prefix = appId.namespace ? `${appId.namespace}/` : "";
+            yield (0, request_1.dispatchRequest)({
+              method: "put",
+              targetUrl: (0, request_1.buildUrl)(`${prefix}${appId.owner}/${appId.alias}`, {
+                subdomain: "queue",
+                path: `/requests/${requestId}/cancel`
+              }),
+              config: config4,
+              options: {
+                signal: abortSignal
+              }
+            });
+          });
+        }
+      };
+      return ref;
+    };
+    exports.createQueueClient = createQueueClient;
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/utf8.cjs
+var require_utf8 = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/utf8.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.utf8Count = utf8Count;
+    exports.utf8EncodeJs = utf8EncodeJs;
+    exports.utf8EncodeTE = utf8EncodeTE;
+    exports.utf8Encode = utf8Encode;
+    exports.utf8DecodeJs = utf8DecodeJs;
+    exports.utf8DecodeTD = utf8DecodeTD;
+    exports.utf8Decode = utf8Decode;
+    function utf8Count(str) {
+      const strLength = str.length;
+      let byteLength = 0;
+      let pos = 0;
+      while (pos < strLength) {
+        let value = str.charCodeAt(pos++);
+        if ((value & 4294967168) === 0) {
+          byteLength++;
+          continue;
+        } else if ((value & 4294965248) === 0) {
+          byteLength += 2;
+        } else {
+          if (value >= 55296 && value <= 56319) {
+            if (pos < strLength) {
+              const extra = str.charCodeAt(pos);
+              if ((extra & 64512) === 56320) {
+                ++pos;
+                value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+              }
+            }
+          }
+          if ((value & 4294901760) === 0) {
+            byteLength += 3;
+          } else {
+            byteLength += 4;
+          }
+        }
+      }
+      return byteLength;
+    }
+    function utf8EncodeJs(str, output3, outputOffset) {
+      const strLength = str.length;
+      let offset = outputOffset;
+      let pos = 0;
+      while (pos < strLength) {
+        let value = str.charCodeAt(pos++);
+        if ((value & 4294967168) === 0) {
+          output3[offset++] = value;
+          continue;
+        } else if ((value & 4294965248) === 0) {
+          output3[offset++] = value >> 6 & 31 | 192;
+        } else {
+          if (value >= 55296 && value <= 56319) {
+            if (pos < strLength) {
+              const extra = str.charCodeAt(pos);
+              if ((extra & 64512) === 56320) {
+                ++pos;
+                value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+              }
+            }
+          }
+          if ((value & 4294901760) === 0) {
+            output3[offset++] = value >> 12 & 15 | 224;
+            output3[offset++] = value >> 6 & 63 | 128;
+          } else {
+            output3[offset++] = value >> 18 & 7 | 240;
+            output3[offset++] = value >> 12 & 63 | 128;
+            output3[offset++] = value >> 6 & 63 | 128;
+          }
+        }
+        output3[offset++] = value & 63 | 128;
+      }
+    }
+    var sharedTextEncoder = new TextEncoder();
+    var TEXT_ENCODER_THRESHOLD = 50;
+    function utf8EncodeTE(str, output3, outputOffset) {
+      sharedTextEncoder.encodeInto(str, output3.subarray(outputOffset));
+    }
+    function utf8Encode(str, output3, outputOffset) {
+      if (str.length > TEXT_ENCODER_THRESHOLD) {
+        utf8EncodeTE(str, output3, outputOffset);
+      } else {
+        utf8EncodeJs(str, output3, outputOffset);
+      }
+    }
+    var CHUNK_SIZE = 4096;
+    function utf8DecodeJs(bytes, inputOffset, byteLength) {
+      let offset = inputOffset;
+      const end = offset + byteLength;
+      const units2 = [];
+      let result = "";
+      while (offset < end) {
+        const byte1 = bytes[offset++];
+        if ((byte1 & 128) === 0) {
+          units2.push(byte1);
+        } else if ((byte1 & 224) === 192) {
+          const byte2 = bytes[offset++] & 63;
+          units2.push((byte1 & 31) << 6 | byte2);
+        } else if ((byte1 & 240) === 224) {
+          const byte2 = bytes[offset++] & 63;
+          const byte3 = bytes[offset++] & 63;
+          units2.push((byte1 & 31) << 12 | byte2 << 6 | byte3);
+        } else if ((byte1 & 248) === 240) {
+          const byte2 = bytes[offset++] & 63;
+          const byte3 = bytes[offset++] & 63;
+          const byte4 = bytes[offset++] & 63;
+          let unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
+          if (unit > 65535) {
+            unit -= 65536;
+            units2.push(unit >>> 10 & 1023 | 55296);
+            unit = 56320 | unit & 1023;
+          }
+          units2.push(unit);
+        } else {
+          units2.push(byte1);
+        }
+        if (units2.length >= CHUNK_SIZE) {
+          result += String.fromCharCode(...units2);
+          units2.length = 0;
+        }
+      }
+      if (units2.length > 0) {
+        result += String.fromCharCode(...units2);
+      }
+      return result;
+    }
+    var sharedTextDecoder = new TextDecoder();
+    var TEXT_DECODER_THRESHOLD = 200;
+    function utf8DecodeTD(bytes, inputOffset, byteLength) {
+      const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+      return sharedTextDecoder.decode(stringBytes);
+    }
+    function utf8Decode(bytes, inputOffset, byteLength) {
+      if (byteLength > TEXT_DECODER_THRESHOLD) {
+        return utf8DecodeTD(bytes, inputOffset, byteLength);
+      } else {
+        return utf8DecodeJs(bytes, inputOffset, byteLength);
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/ExtData.cjs
+var require_ExtData = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/ExtData.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExtData = void 0;
+    var ExtData = class {
+      type;
+      data;
+      constructor(type, data) {
+        this.type = type;
+        this.data = data;
+      }
+    };
+    exports.ExtData = ExtData;
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/DecodeError.cjs
+var require_DecodeError = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/DecodeError.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DecodeError = void 0;
+    var DecodeError = class _DecodeError extends Error {
+      constructor(message) {
+        super(message);
+        const proto2 = Object.create(_DecodeError.prototype);
+        Object.setPrototypeOf(this, proto2);
+        Object.defineProperty(this, "name", {
+          configurable: true,
+          enumerable: false,
+          value: _DecodeError.name
+        });
+      }
+    };
+    exports.DecodeError = DecodeError;
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/int.cjs
+var require_int2 = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/int.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.UINT32_MAX = void 0;
+    exports.setUint64 = setUint64;
+    exports.setInt64 = setInt64;
+    exports.getInt64 = getInt64;
+    exports.getUint64 = getUint64;
+    exports.UINT32_MAX = 4294967295;
+    function setUint64(view, offset, value) {
+      const high = value / 4294967296;
+      const low = value;
+      view.setUint32(offset, high);
+      view.setUint32(offset + 4, low);
+    }
+    function setInt64(view, offset, value) {
+      const high = Math.floor(value / 4294967296);
+      const low = value;
+      view.setUint32(offset, high);
+      view.setUint32(offset + 4, low);
+    }
+    function getInt64(view, offset) {
+      const high = view.getInt32(offset);
+      const low = view.getUint32(offset + 4);
+      return high * 4294967296 + low;
+    }
+    function getUint64(view, offset) {
+      const high = view.getUint32(offset);
+      const low = view.getUint32(offset + 4);
+      return high * 4294967296 + low;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/timestamp.cjs
+var require_timestamp2 = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/timestamp.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.timestampExtension = exports.EXT_TIMESTAMP = void 0;
+    exports.encodeTimeSpecToTimestamp = encodeTimeSpecToTimestamp;
+    exports.encodeDateToTimeSpec = encodeDateToTimeSpec;
+    exports.encodeTimestampExtension = encodeTimestampExtension;
+    exports.decodeTimestampToTimeSpec = decodeTimestampToTimeSpec;
+    exports.decodeTimestampExtension = decodeTimestampExtension;
+    var DecodeError_ts_1 = require_DecodeError();
+    var int_ts_1 = require_int2();
+    exports.EXT_TIMESTAMP = -1;
+    var TIMESTAMP32_MAX_SEC = 4294967296 - 1;
+    var TIMESTAMP64_MAX_SEC = 17179869184 - 1;
+    function encodeTimeSpecToTimestamp({ sec, nsec }) {
+      if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
+        if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+          const rv = new Uint8Array(4);
+          const view = new DataView(rv.buffer);
+          view.setUint32(0, sec);
+          return rv;
+        } else {
+          const secHigh = sec / 4294967296;
+          const secLow = sec & 4294967295;
+          const rv = new Uint8Array(8);
+          const view = new DataView(rv.buffer);
+          view.setUint32(0, nsec << 2 | secHigh & 3);
+          view.setUint32(4, secLow);
+          return rv;
+        }
+      } else {
+        const rv = new Uint8Array(12);
+        const view = new DataView(rv.buffer);
+        view.setUint32(0, nsec);
+        (0, int_ts_1.setInt64)(view, 4, sec);
+        return rv;
+      }
+    }
+    function encodeDateToTimeSpec(date) {
+      const msec = date.getTime();
+      const sec = Math.floor(msec / 1e3);
+      const nsec = (msec - sec * 1e3) * 1e6;
+      const nsecInSec = Math.floor(nsec / 1e9);
+      return {
+        sec: sec + nsecInSec,
+        nsec: nsec - nsecInSec * 1e9
+      };
+    }
+    function encodeTimestampExtension(object) {
+      if (object instanceof Date) {
+        const timeSpec = encodeDateToTimeSpec(object);
+        return encodeTimeSpecToTimestamp(timeSpec);
+      } else {
+        return null;
+      }
+    }
+    function decodeTimestampToTimeSpec(data) {
+      const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      switch (data.byteLength) {
+        case 4: {
+          const sec = view.getUint32(0);
+          const nsec = 0;
+          return { sec, nsec };
+        }
+        case 8: {
+          const nsec30AndSecHigh2 = view.getUint32(0);
+          const secLow32 = view.getUint32(4);
+          const sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32;
+          const nsec = nsec30AndSecHigh2 >>> 2;
+          return { sec, nsec };
+        }
+        case 12: {
+          const sec = (0, int_ts_1.getInt64)(view, 4);
+          const nsec = view.getUint32(0);
+          return { sec, nsec };
+        }
+        default:
+          throw new DecodeError_ts_1.DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
+      }
+    }
+    function decodeTimestampExtension(data) {
+      const timeSpec = decodeTimestampToTimeSpec(data);
+      return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+    }
+    exports.timestampExtension = {
+      type: exports.EXT_TIMESTAMP,
+      encode: encodeTimestampExtension,
+      decode: decodeTimestampExtension
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/ExtensionCodec.cjs
+var require_ExtensionCodec = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/ExtensionCodec.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExtensionCodec = void 0;
+    var ExtData_ts_1 = require_ExtData();
+    var timestamp_ts_1 = require_timestamp2();
+    var ExtensionCodec = class _ExtensionCodec {
+      static defaultCodec = new _ExtensionCodec();
+      // ensures ExtensionCodecType<X> matches ExtensionCodec<X>
+      // this will make type errors a lot more clear
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      __brand;
+      // built-in extensions
+      builtInEncoders = [];
+      builtInDecoders = [];
+      // custom extensions
+      encoders = [];
+      decoders = [];
+      constructor() {
+        this.register(timestamp_ts_1.timestampExtension);
+      }
+      register({ type, encode, decode }) {
+        if (type >= 0) {
+          this.encoders[type] = encode;
+          this.decoders[type] = decode;
+        } else {
+          const index = -1 - type;
+          this.builtInEncoders[index] = encode;
+          this.builtInDecoders[index] = decode;
+        }
+      }
+      tryToEncode(object, context3) {
+        for (let i = 0; i < this.builtInEncoders.length; i++) {
+          const encodeExt = this.builtInEncoders[i];
+          if (encodeExt != null) {
+            const data = encodeExt(object, context3);
+            if (data != null) {
+              const type = -1 - i;
+              return new ExtData_ts_1.ExtData(type, data);
+            }
+          }
+        }
+        for (let i = 0; i < this.encoders.length; i++) {
+          const encodeExt = this.encoders[i];
+          if (encodeExt != null) {
+            const data = encodeExt(object, context3);
+            if (data != null) {
+              const type = i;
+              return new ExtData_ts_1.ExtData(type, data);
+            }
+          }
+        }
+        if (object instanceof ExtData_ts_1.ExtData) {
+          return object;
+        }
+        return null;
+      }
+      decode(data, type, context3) {
+        const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+        if (decodeExt) {
+          return decodeExt(data, type, context3);
+        } else {
+          return new ExtData_ts_1.ExtData(type, data);
+        }
+      }
+    };
+    exports.ExtensionCodec = ExtensionCodec;
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/typedArrays.cjs
+var require_typedArrays = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/typedArrays.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ensureUint8Array = ensureUint8Array;
+    function isArrayBufferLike(buffer) {
+      return buffer instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
+    }
+    function ensureUint8Array(buffer) {
+      if (buffer instanceof Uint8Array) {
+        return buffer;
+      } else if (ArrayBuffer.isView(buffer)) {
+        return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      } else if (isArrayBufferLike(buffer)) {
+        return new Uint8Array(buffer);
+      } else {
+        return Uint8Array.from(buffer);
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/Encoder.cjs
+var require_Encoder = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/Encoder.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Encoder = exports.DEFAULT_INITIAL_BUFFER_SIZE = exports.DEFAULT_MAX_DEPTH = void 0;
+    var utf8_ts_1 = require_utf8();
+    var ExtensionCodec_ts_1 = require_ExtensionCodec();
+    var int_ts_1 = require_int2();
+    var typedArrays_ts_1 = require_typedArrays();
+    exports.DEFAULT_MAX_DEPTH = 100;
+    exports.DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+    var Encoder = class _Encoder {
+      extensionCodec;
+      context;
+      useBigInt64;
+      maxDepth;
+      initialBufferSize;
+      sortKeys;
+      forceFloat32;
+      ignoreUndefined;
+      forceIntegerToFloat;
+      pos;
+      view;
+      bytes;
+      entered = false;
+      constructor(options) {
+        this.extensionCodec = options?.extensionCodec ?? ExtensionCodec_ts_1.ExtensionCodec.defaultCodec;
+        this.context = options?.context;
+        this.useBigInt64 = options?.useBigInt64 ?? false;
+        this.maxDepth = options?.maxDepth ?? exports.DEFAULT_MAX_DEPTH;
+        this.initialBufferSize = options?.initialBufferSize ?? exports.DEFAULT_INITIAL_BUFFER_SIZE;
+        this.sortKeys = options?.sortKeys ?? false;
+        this.forceFloat32 = options?.forceFloat32 ?? false;
+        this.ignoreUndefined = options?.ignoreUndefined ?? false;
+        this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
+        this.pos = 0;
+        this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+        this.bytes = new Uint8Array(this.view.buffer);
+      }
+      clone() {
+        return new _Encoder({
+          extensionCodec: this.extensionCodec,
+          context: this.context,
+          useBigInt64: this.useBigInt64,
+          maxDepth: this.maxDepth,
+          initialBufferSize: this.initialBufferSize,
+          sortKeys: this.sortKeys,
+          forceFloat32: this.forceFloat32,
+          ignoreUndefined: this.ignoreUndefined,
+          forceIntegerToFloat: this.forceIntegerToFloat
+        });
+      }
+      reinitializeState() {
+        this.pos = 0;
+      }
+      /**
+       * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+       *
+       * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+       */
+      encodeSharedRef(object) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.encodeSharedRef(object);
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.doEncode(object, 1);
+          return this.bytes.subarray(0, this.pos);
+        } finally {
+          this.entered = false;
+        }
+      }
+      /**
+       * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+       */
+      encode(object) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.encode(object);
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.doEncode(object, 1);
+          return this.bytes.slice(0, this.pos);
+        } finally {
+          this.entered = false;
+        }
+      }
+      doEncode(object, depth) {
+        if (depth > this.maxDepth) {
+          throw new Error(`Too deep objects in depth ${depth}`);
+        }
+        if (object == null) {
+          this.encodeNil();
+        } else if (typeof object === "boolean") {
+          this.encodeBoolean(object);
+        } else if (typeof object === "number") {
+          if (!this.forceIntegerToFloat) {
+            this.encodeNumber(object);
+          } else {
+            this.encodeNumberAsFloat(object);
+          }
+        } else if (typeof object === "string") {
+          this.encodeString(object);
+        } else if (this.useBigInt64 && typeof object === "bigint") {
+          this.encodeBigInt64(object);
+        } else {
+          this.encodeObject(object, depth);
+        }
+      }
+      ensureBufferSizeToWrite(sizeToWrite) {
+        const requiredSize = this.pos + sizeToWrite;
+        if (this.view.byteLength < requiredSize) {
+          this.resizeBuffer(requiredSize * 2);
+        }
+      }
+      resizeBuffer(newSize) {
+        const newBuffer = new ArrayBuffer(newSize);
+        const newBytes = new Uint8Array(newBuffer);
+        const newView = new DataView(newBuffer);
+        newBytes.set(this.bytes);
+        this.view = newView;
+        this.bytes = newBytes;
+      }
+      encodeNil() {
+        this.writeU8(192);
+      }
+      encodeBoolean(object) {
+        if (object === false) {
+          this.writeU8(194);
+        } else {
+          this.writeU8(195);
+        }
+      }
+      encodeNumber(object) {
+        if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
+          if (object >= 0) {
+            if (object < 128) {
+              this.writeU8(object);
+            } else if (object < 256) {
+              this.writeU8(204);
+              this.writeU8(object);
+            } else if (object < 65536) {
+              this.writeU8(205);
+              this.writeU16(object);
+            } else if (object < 4294967296) {
+              this.writeU8(206);
+              this.writeU32(object);
+            } else if (!this.useBigInt64) {
+              this.writeU8(207);
+              this.writeU64(object);
+            } else {
+              this.encodeNumberAsFloat(object);
+            }
+          } else {
+            if (object >= -32) {
+              this.writeU8(224 | object + 32);
+            } else if (object >= -128) {
+              this.writeU8(208);
+              this.writeI8(object);
+            } else if (object >= -32768) {
+              this.writeU8(209);
+              this.writeI16(object);
+            } else if (object >= -2147483648) {
+              this.writeU8(210);
+              this.writeI32(object);
+            } else if (!this.useBigInt64) {
+              this.writeU8(211);
+              this.writeI64(object);
+            } else {
+              this.encodeNumberAsFloat(object);
+            }
+          }
+        } else {
+          this.encodeNumberAsFloat(object);
+        }
+      }
+      encodeNumberAsFloat(object) {
+        if (this.forceFloat32) {
+          this.writeU8(202);
+          this.writeF32(object);
+        } else {
+          this.writeU8(203);
+          this.writeF64(object);
+        }
+      }
+      encodeBigInt64(object) {
+        if (object >= BigInt(0)) {
+          this.writeU8(207);
+          this.writeBigUint64(object);
+        } else {
+          this.writeU8(211);
+          this.writeBigInt64(object);
+        }
+      }
+      writeStringHeader(byteLength) {
+        if (byteLength < 32) {
+          this.writeU8(160 + byteLength);
+        } else if (byteLength < 256) {
+          this.writeU8(217);
+          this.writeU8(byteLength);
+        } else if (byteLength < 65536) {
+          this.writeU8(218);
+          this.writeU16(byteLength);
+        } else if (byteLength < 4294967296) {
+          this.writeU8(219);
+          this.writeU32(byteLength);
+        } else {
+          throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);
+        }
+      }
+      encodeString(object) {
+        const maxHeaderSize = 1 + 4;
+        const byteLength = (0, utf8_ts_1.utf8Count)(object);
+        this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+        this.writeStringHeader(byteLength);
+        (0, utf8_ts_1.utf8Encode)(object, this.bytes, this.pos);
+        this.pos += byteLength;
+      }
+      encodeObject(object, depth) {
+        const ext = this.extensionCodec.tryToEncode(object, this.context);
+        if (ext != null) {
+          this.encodeExtension(ext);
+        } else if (Array.isArray(object)) {
+          this.encodeArray(object, depth);
+        } else if (ArrayBuffer.isView(object)) {
+          this.encodeBinary(object);
+        } else if (typeof object === "object") {
+          this.encodeMap(object, depth);
+        } else {
+          throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+        }
+      }
+      encodeBinary(object) {
+        const size = object.byteLength;
+        if (size < 256) {
+          this.writeU8(196);
+          this.writeU8(size);
+        } else if (size < 65536) {
+          this.writeU8(197);
+          this.writeU16(size);
+        } else if (size < 4294967296) {
+          this.writeU8(198);
+          this.writeU32(size);
+        } else {
+          throw new Error(`Too large binary: ${size}`);
+        }
+        const bytes = (0, typedArrays_ts_1.ensureUint8Array)(object);
+        this.writeU8a(bytes);
+      }
+      encodeArray(object, depth) {
+        const size = object.length;
+        if (size < 16) {
+          this.writeU8(144 + size);
+        } else if (size < 65536) {
+          this.writeU8(220);
+          this.writeU16(size);
+        } else if (size < 4294967296) {
+          this.writeU8(221);
+          this.writeU32(size);
+        } else {
+          throw new Error(`Too large array: ${size}`);
+        }
+        for (const item of object) {
+          this.doEncode(item, depth + 1);
+        }
+      }
+      countWithoutUndefined(object, keys2) {
+        let count = 0;
+        for (const key2 of keys2) {
+          if (object[key2] !== void 0) {
+            count++;
+          }
+        }
+        return count;
+      }
+      encodeMap(object, depth) {
+        const keys2 = Object.keys(object);
+        if (this.sortKeys) {
+          keys2.sort();
+        }
+        const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys2) : keys2.length;
+        if (size < 16) {
+          this.writeU8(128 + size);
+        } else if (size < 65536) {
+          this.writeU8(222);
+          this.writeU16(size);
+        } else if (size < 4294967296) {
+          this.writeU8(223);
+          this.writeU32(size);
+        } else {
+          throw new Error(`Too large map object: ${size}`);
+        }
+        for (const key2 of keys2) {
+          const value = object[key2];
+          if (!(this.ignoreUndefined && value === void 0)) {
+            this.encodeString(key2);
+            this.doEncode(value, depth + 1);
+          }
+        }
+      }
+      encodeExtension(ext) {
+        if (typeof ext.data === "function") {
+          const data = ext.data(this.pos + 6);
+          const size2 = data.length;
+          if (size2 >= 4294967296) {
+            throw new Error(`Too large extension object: ${size2}`);
+          }
+          this.writeU8(201);
+          this.writeU32(size2);
+          this.writeI8(ext.type);
+          this.writeU8a(data);
+          return;
+        }
+        const size = ext.data.length;
+        if (size === 1) {
+          this.writeU8(212);
+        } else if (size === 2) {
+          this.writeU8(213);
+        } else if (size === 4) {
+          this.writeU8(214);
+        } else if (size === 8) {
+          this.writeU8(215);
+        } else if (size === 16) {
+          this.writeU8(216);
+        } else if (size < 256) {
+          this.writeU8(199);
+          this.writeU8(size);
+        } else if (size < 65536) {
+          this.writeU8(200);
+          this.writeU16(size);
+        } else if (size < 4294967296) {
+          this.writeU8(201);
+          this.writeU32(size);
+        } else {
+          throw new Error(`Too large extension object: ${size}`);
+        }
+        this.writeI8(ext.type);
+        this.writeU8a(ext.data);
+      }
+      writeU8(value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setUint8(this.pos, value);
+        this.pos++;
+      }
+      writeU8a(values) {
+        const size = values.length;
+        this.ensureBufferSizeToWrite(size);
+        this.bytes.set(values, this.pos);
+        this.pos += size;
+      }
+      writeI8(value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setInt8(this.pos, value);
+        this.pos++;
+      }
+      writeU16(value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setUint16(this.pos, value);
+        this.pos += 2;
+      }
+      writeI16(value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setInt16(this.pos, value);
+        this.pos += 2;
+      }
+      writeU32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setUint32(this.pos, value);
+        this.pos += 4;
+      }
+      writeI32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setInt32(this.pos, value);
+        this.pos += 4;
+      }
+      writeF32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setFloat32(this.pos, value);
+        this.pos += 4;
+      }
+      writeF64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setFloat64(this.pos, value);
+        this.pos += 8;
+      }
+      writeU64(value) {
+        this.ensureBufferSizeToWrite(8);
+        (0, int_ts_1.setUint64)(this.view, this.pos, value);
+        this.pos += 8;
+      }
+      writeI64(value) {
+        this.ensureBufferSizeToWrite(8);
+        (0, int_ts_1.setInt64)(this.view, this.pos, value);
+        this.pos += 8;
+      }
+      writeBigUint64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setBigUint64(this.pos, value);
+        this.pos += 8;
+      }
+      writeBigInt64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setBigInt64(this.pos, value);
+        this.pos += 8;
+      }
+    };
+    exports.Encoder = Encoder;
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/encode.cjs
+var require_encode = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/encode.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.encode = encode;
+    var Encoder_ts_1 = require_Encoder();
+    function encode(value, options) {
+      const encoder = new Encoder_ts_1.Encoder(options);
+      return encoder.encodeSharedRef(value);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/prettyByte.cjs
+var require_prettyByte = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/prettyByte.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.prettyByte = prettyByte;
+    function prettyByte(byte) {
+      return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/CachedKeyDecoder.cjs
+var require_CachedKeyDecoder = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/CachedKeyDecoder.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CachedKeyDecoder = void 0;
+    var utf8_ts_1 = require_utf8();
+    var DEFAULT_MAX_KEY_LENGTH = 16;
+    var DEFAULT_MAX_LENGTH_PER_KEY = 16;
+    var CachedKeyDecoder = class {
+      hit = 0;
+      miss = 0;
+      caches;
+      maxKeyLength;
+      maxLengthPerKey;
+      constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+        this.maxKeyLength = maxKeyLength;
+        this.maxLengthPerKey = maxLengthPerKey;
+        this.caches = [];
+        for (let i = 0; i < this.maxKeyLength; i++) {
+          this.caches.push([]);
+        }
+      }
+      canBeCached(byteLength) {
+        return byteLength > 0 && byteLength <= this.maxKeyLength;
+      }
+      find(bytes, inputOffset, byteLength) {
+        const records = this.caches[byteLength - 1];
+        FIND_CHUNK: for (const record of records) {
+          const recordBytes = record.bytes;
+          for (let j = 0; j < byteLength; j++) {
+            if (recordBytes[j] !== bytes[inputOffset + j]) {
+              continue FIND_CHUNK;
+            }
+          }
+          return record.str;
+        }
+        return null;
+      }
+      store(bytes, value) {
+        const records = this.caches[bytes.length - 1];
+        const record = { bytes, str: value };
+        if (records.length >= this.maxLengthPerKey) {
+          records[Math.random() * records.length | 0] = record;
+        } else {
+          records.push(record);
+        }
+      }
+      decode(bytes, inputOffset, byteLength) {
+        const cachedValue = this.find(bytes, inputOffset, byteLength);
+        if (cachedValue != null) {
+          this.hit++;
+          return cachedValue;
+        }
+        this.miss++;
+        const str = (0, utf8_ts_1.utf8DecodeJs)(bytes, inputOffset, byteLength);
+        const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+        this.store(slicedCopyOfBytes, str);
+        return str;
+      }
+    };
+    exports.CachedKeyDecoder = CachedKeyDecoder;
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/Decoder.cjs
+var require_Decoder = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/Decoder.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Decoder = void 0;
+    var prettyByte_ts_1 = require_prettyByte();
+    var ExtensionCodec_ts_1 = require_ExtensionCodec();
+    var int_ts_1 = require_int2();
+    var utf8_ts_1 = require_utf8();
+    var typedArrays_ts_1 = require_typedArrays();
+    var CachedKeyDecoder_ts_1 = require_CachedKeyDecoder();
+    var DecodeError_ts_1 = require_DecodeError();
+    var STATE_ARRAY = "array";
+    var STATE_MAP_KEY = "map_key";
+    var STATE_MAP_VALUE = "map_value";
+    var mapKeyConverter = (key2) => {
+      if (typeof key2 === "string" || typeof key2 === "number") {
+        return key2;
+      }
+      throw new DecodeError_ts_1.DecodeError("The type of key must be string or number but " + typeof key2);
+    };
+    var StackPool = class {
+      stack = [];
+      stackHeadPosition = -1;
+      get length() {
+        return this.stackHeadPosition + 1;
+      }
+      top() {
+        return this.stack[this.stackHeadPosition];
+      }
+      pushArrayState(size) {
+        const state = this.getUninitializedStateFromPool();
+        state.type = STATE_ARRAY;
+        state.position = 0;
+        state.size = size;
+        state.array = new Array(size);
+      }
+      pushMapState(size) {
+        const state = this.getUninitializedStateFromPool();
+        state.type = STATE_MAP_KEY;
+        state.readCount = 0;
+        state.size = size;
+        state.map = {};
+      }
+      getUninitializedStateFromPool() {
+        this.stackHeadPosition++;
+        if (this.stackHeadPosition === this.stack.length) {
+          const partialState = {
+            type: void 0,
+            size: 0,
+            array: void 0,
+            position: 0,
+            readCount: 0,
+            map: void 0,
+            key: null
+          };
+          this.stack.push(partialState);
+        }
+        return this.stack[this.stackHeadPosition];
+      }
+      release(state) {
+        const topStackState = this.stack[this.stackHeadPosition];
+        if (topStackState !== state) {
+          throw new Error("Invalid stack state. Released state is not on top of the stack.");
+        }
+        if (state.type === STATE_ARRAY) {
+          const partialState = state;
+          partialState.size = 0;
+          partialState.array = void 0;
+          partialState.position = 0;
+          partialState.type = void 0;
+        }
+        if (state.type === STATE_MAP_KEY || state.type === STATE_MAP_VALUE) {
+          const partialState = state;
+          partialState.size = 0;
+          partialState.map = void 0;
+          partialState.readCount = 0;
+          partialState.type = void 0;
+        }
+        this.stackHeadPosition--;
+      }
+      reset() {
+        this.stack.length = 0;
+        this.stackHeadPosition = -1;
+      }
+    };
+    var HEAD_BYTE_REQUIRED = -1;
+    var EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+    var EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
+    try {
+      EMPTY_VIEW.getInt8(0);
+    } catch (e) {
+      if (!(e instanceof RangeError)) {
+        throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
+      }
+    }
+    var MORE_DATA = new RangeError("Insufficient data");
+    var sharedCachedKeyDecoder = new CachedKeyDecoder_ts_1.CachedKeyDecoder();
+    var Decoder = class _Decoder {
+      extensionCodec;
+      context;
+      useBigInt64;
+      rawStrings;
+      maxStrLength;
+      maxBinLength;
+      maxArrayLength;
+      maxMapLength;
+      maxExtLength;
+      keyDecoder;
+      mapKeyConverter;
+      totalPos = 0;
+      pos = 0;
+      view = EMPTY_VIEW;
+      bytes = EMPTY_BYTES;
+      headByte = HEAD_BYTE_REQUIRED;
+      stack = new StackPool();
+      entered = false;
+      constructor(options) {
+        this.extensionCodec = options?.extensionCodec ?? ExtensionCodec_ts_1.ExtensionCodec.defaultCodec;
+        this.context = options?.context;
+        this.useBigInt64 = options?.useBigInt64 ?? false;
+        this.rawStrings = options?.rawStrings ?? false;
+        this.maxStrLength = options?.maxStrLength ?? int_ts_1.UINT32_MAX;
+        this.maxBinLength = options?.maxBinLength ?? int_ts_1.UINT32_MAX;
+        this.maxArrayLength = options?.maxArrayLength ?? int_ts_1.UINT32_MAX;
+        this.maxMapLength = options?.maxMapLength ?? int_ts_1.UINT32_MAX;
+        this.maxExtLength = options?.maxExtLength ?? int_ts_1.UINT32_MAX;
+        this.keyDecoder = options?.keyDecoder !== void 0 ? options.keyDecoder : sharedCachedKeyDecoder;
+        this.mapKeyConverter = options?.mapKeyConverter ?? mapKeyConverter;
+      }
+      clone() {
+        return new _Decoder({
+          extensionCodec: this.extensionCodec,
+          context: this.context,
+          useBigInt64: this.useBigInt64,
+          rawStrings: this.rawStrings,
+          maxStrLength: this.maxStrLength,
+          maxBinLength: this.maxBinLength,
+          maxArrayLength: this.maxArrayLength,
+          maxMapLength: this.maxMapLength,
+          maxExtLength: this.maxExtLength,
+          keyDecoder: this.keyDecoder
+        });
+      }
+      reinitializeState() {
+        this.totalPos = 0;
+        this.headByte = HEAD_BYTE_REQUIRED;
+        this.stack.reset();
+      }
+      setBuffer(buffer) {
+        const bytes = (0, typedArrays_ts_1.ensureUint8Array)(buffer);
+        this.bytes = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        this.pos = 0;
+      }
+      appendBuffer(buffer) {
+        if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
+          this.setBuffer(buffer);
+        } else {
+          const remainingData = this.bytes.subarray(this.pos);
+          const newData = (0, typedArrays_ts_1.ensureUint8Array)(buffer);
+          const newBuffer = new Uint8Array(remainingData.length + newData.length);
+          newBuffer.set(remainingData);
+          newBuffer.set(newData, remainingData.length);
+          this.setBuffer(newBuffer);
+        }
+      }
+      hasRemaining(size) {
+        return this.view.byteLength - this.pos >= size;
+      }
+      createExtraByteError(posToShow) {
+        const { view, pos } = this;
+        return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`);
+      }
+      /**
+       * @throws {@link DecodeError}
+       * @throws {@link RangeError}
+       */
+      decode(buffer) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.decode(buffer);
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.setBuffer(buffer);
+          const object = this.doDecodeSync();
+          if (this.hasRemaining(1)) {
+            throw this.createExtraByteError(this.pos);
+          }
+          return object;
+        } finally {
+          this.entered = false;
+        }
+      }
+      *decodeMulti(buffer) {
+        if (this.entered) {
+          const instance = this.clone();
+          yield* instance.decodeMulti(buffer);
+          return;
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.setBuffer(buffer);
+          while (this.hasRemaining(1)) {
+            yield this.doDecodeSync();
+          }
+        } finally {
+          this.entered = false;
+        }
+      }
+      async decodeAsync(stream) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.decodeAsync(stream);
+        }
+        try {
+          this.entered = true;
+          let decoded = false;
+          let object;
+          for await (const buffer of stream) {
+            if (decoded) {
+              this.entered = false;
+              throw this.createExtraByteError(this.totalPos);
+            }
+            this.appendBuffer(buffer);
+            try {
+              object = this.doDecodeSync();
+              decoded = true;
+            } catch (e) {
+              if (!(e instanceof RangeError)) {
+                throw e;
+              }
+            }
+            this.totalPos += this.pos;
+          }
+          if (decoded) {
+            if (this.hasRemaining(1)) {
+              throw this.createExtraByteError(this.totalPos);
+            }
+            return object;
+          }
+          const { headByte, pos, totalPos } = this;
+          throw new RangeError(`Insufficient data in parsing ${(0, prettyByte_ts_1.prettyByte)(headByte)} at ${totalPos} (${pos} in the current buffer)`);
+        } finally {
+          this.entered = false;
+        }
+      }
+      decodeArrayStream(stream) {
+        return this.decodeMultiAsync(stream, true);
+      }
+      decodeStream(stream) {
+        return this.decodeMultiAsync(stream, false);
+      }
+      async *decodeMultiAsync(stream, isArray5) {
+        if (this.entered) {
+          const instance = this.clone();
+          yield* instance.decodeMultiAsync(stream, isArray5);
+          return;
+        }
+        try {
+          this.entered = true;
+          let isArrayHeaderRequired = isArray5;
+          let arrayItemsLeft = -1;
+          for await (const buffer of stream) {
+            if (isArray5 && arrayItemsLeft === 0) {
+              throw this.createExtraByteError(this.totalPos);
+            }
+            this.appendBuffer(buffer);
+            if (isArrayHeaderRequired) {
+              arrayItemsLeft = this.readArraySize();
+              isArrayHeaderRequired = false;
+              this.complete();
+            }
+            try {
+              while (true) {
+                yield this.doDecodeSync();
+                if (--arrayItemsLeft === 0) {
+                  break;
+                }
+              }
+            } catch (e) {
+              if (!(e instanceof RangeError)) {
+                throw e;
+              }
+            }
+            this.totalPos += this.pos;
+          }
+        } finally {
+          this.entered = false;
+        }
+      }
+      doDecodeSync() {
+        DECODE: while (true) {
+          const headByte = this.readHeadByte();
+          let object;
+          if (headByte >= 224) {
+            object = headByte - 256;
+          } else if (headByte < 192) {
+            if (headByte < 128) {
+              object = headByte;
+            } else if (headByte < 144) {
+              const size = headByte - 128;
+              if (size !== 0) {
+                this.pushMapState(size);
+                this.complete();
+                continue DECODE;
+              } else {
+                object = {};
+              }
+            } else if (headByte < 160) {
+              const size = headByte - 144;
+              if (size !== 0) {
+                this.pushArrayState(size);
+                this.complete();
+                continue DECODE;
+              } else {
+                object = [];
+              }
+            } else {
+              const byteLength = headByte - 160;
+              object = this.decodeString(byteLength, 0);
+            }
+          } else if (headByte === 192) {
+            object = null;
+          } else if (headByte === 194) {
+            object = false;
+          } else if (headByte === 195) {
+            object = true;
+          } else if (headByte === 202) {
+            object = this.readF32();
+          } else if (headByte === 203) {
+            object = this.readF64();
+          } else if (headByte === 204) {
+            object = this.readU8();
+          } else if (headByte === 205) {
+            object = this.readU16();
+          } else if (headByte === 206) {
+            object = this.readU32();
+          } else if (headByte === 207) {
+            if (this.useBigInt64) {
+              object = this.readU64AsBigInt();
+            } else {
+              object = this.readU64();
+            }
+          } else if (headByte === 208) {
+            object = this.readI8();
+          } else if (headByte === 209) {
+            object = this.readI16();
+          } else if (headByte === 210) {
+            object = this.readI32();
+          } else if (headByte === 211) {
+            if (this.useBigInt64) {
+              object = this.readI64AsBigInt();
+            } else {
+              object = this.readI64();
+            }
+          } else if (headByte === 217) {
+            const byteLength = this.lookU8();
+            object = this.decodeString(byteLength, 1);
+          } else if (headByte === 218) {
+            const byteLength = this.lookU16();
+            object = this.decodeString(byteLength, 2);
+          } else if (headByte === 219) {
+            const byteLength = this.lookU32();
+            object = this.decodeString(byteLength, 4);
+          } else if (headByte === 220) {
+            const size = this.readU16();
+            if (size !== 0) {
+              this.pushArrayState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = [];
+            }
+          } else if (headByte === 221) {
+            const size = this.readU32();
+            if (size !== 0) {
+              this.pushArrayState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = [];
+            }
+          } else if (headByte === 222) {
+            const size = this.readU16();
+            if (size !== 0) {
+              this.pushMapState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = {};
+            }
+          } else if (headByte === 223) {
+            const size = this.readU32();
+            if (size !== 0) {
+              this.pushMapState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = {};
+            }
+          } else if (headByte === 196) {
+            const size = this.lookU8();
+            object = this.decodeBinary(size, 1);
+          } else if (headByte === 197) {
+            const size = this.lookU16();
+            object = this.decodeBinary(size, 2);
+          } else if (headByte === 198) {
+            const size = this.lookU32();
+            object = this.decodeBinary(size, 4);
+          } else if (headByte === 212) {
+            object = this.decodeExtension(1, 0);
+          } else if (headByte === 213) {
+            object = this.decodeExtension(2, 0);
+          } else if (headByte === 214) {
+            object = this.decodeExtension(4, 0);
+          } else if (headByte === 215) {
+            object = this.decodeExtension(8, 0);
+          } else if (headByte === 216) {
+            object = this.decodeExtension(16, 0);
+          } else if (headByte === 199) {
+            const size = this.lookU8();
+            object = this.decodeExtension(size, 1);
+          } else if (headByte === 200) {
+            const size = this.lookU16();
+            object = this.decodeExtension(size, 2);
+          } else if (headByte === 201) {
+            const size = this.lookU32();
+            object = this.decodeExtension(size, 4);
+          } else {
+            throw new DecodeError_ts_1.DecodeError(`Unrecognized type byte: ${(0, prettyByte_ts_1.prettyByte)(headByte)}`);
+          }
+          this.complete();
+          const stack = this.stack;
+          while (stack.length > 0) {
+            const state = stack.top();
+            if (state.type === STATE_ARRAY) {
+              state.array[state.position] = object;
+              state.position++;
+              if (state.position === state.size) {
+                object = state.array;
+                stack.release(state);
+              } else {
+                continue DECODE;
+              }
+            } else if (state.type === STATE_MAP_KEY) {
+              if (object === "__proto__") {
+                throw new DecodeError_ts_1.DecodeError("The key __proto__ is not allowed");
+              }
+              state.key = this.mapKeyConverter(object);
+              state.type = STATE_MAP_VALUE;
+              continue DECODE;
+            } else {
+              state.map[state.key] = object;
+              state.readCount++;
+              if (state.readCount === state.size) {
+                object = state.map;
+                stack.release(state);
+              } else {
+                state.key = null;
+                state.type = STATE_MAP_KEY;
+                continue DECODE;
+              }
+            }
+          }
+          return object;
+        }
+      }
+      readHeadByte() {
+        if (this.headByte === HEAD_BYTE_REQUIRED) {
+          this.headByte = this.readU8();
+        }
+        return this.headByte;
+      }
+      complete() {
+        this.headByte = HEAD_BYTE_REQUIRED;
+      }
+      readArraySize() {
+        const headByte = this.readHeadByte();
+        switch (headByte) {
+          case 220:
+            return this.readU16();
+          case 221:
+            return this.readU32();
+          default: {
+            if (headByte < 160) {
+              return headByte - 144;
+            } else {
+              throw new DecodeError_ts_1.DecodeError(`Unrecognized array type byte: ${(0, prettyByte_ts_1.prettyByte)(headByte)}`);
+            }
+          }
+        }
+      }
+      pushMapState(size) {
+        if (size > this.maxMapLength) {
+          throw new DecodeError_ts_1.DecodeError(`Max length exceeded: map length (${size}) > maxMapLengthLength (${this.maxMapLength})`);
+        }
+        this.stack.pushMapState(size);
+      }
+      pushArrayState(size) {
+        if (size > this.maxArrayLength) {
+          throw new DecodeError_ts_1.DecodeError(`Max length exceeded: array length (${size}) > maxArrayLength (${this.maxArrayLength})`);
+        }
+        this.stack.pushArrayState(size);
+      }
+      decodeString(byteLength, headerOffset) {
+        if (!this.rawStrings || this.stateIsMapKey()) {
+          return this.decodeUtf8String(byteLength, headerOffset);
+        }
+        return this.decodeBinary(byteLength, headerOffset);
+      }
+      /**
+       * @throws {@link RangeError}
+       */
+      decodeUtf8String(byteLength, headerOffset) {
+        if (byteLength > this.maxStrLength) {
+          throw new DecodeError_ts_1.DecodeError(`Max length exceeded: UTF-8 byte length (${byteLength}) > maxStrLength (${this.maxStrLength})`);
+        }
+        if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
+          throw MORE_DATA;
+        }
+        const offset = this.pos + headerOffset;
+        let object;
+        if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {
+          object = this.keyDecoder.decode(this.bytes, offset, byteLength);
+        } else {
+          object = (0, utf8_ts_1.utf8Decode)(this.bytes, offset, byteLength);
+        }
+        this.pos += headerOffset + byteLength;
+        return object;
+      }
+      stateIsMapKey() {
+        if (this.stack.length > 0) {
+          const state = this.stack.top();
+          return state.type === STATE_MAP_KEY;
+        }
+        return false;
+      }
+      /**
+       * @throws {@link RangeError}
+       */
+      decodeBinary(byteLength, headOffset) {
+        if (byteLength > this.maxBinLength) {
+          throw new DecodeError_ts_1.DecodeError(`Max length exceeded: bin length (${byteLength}) > maxBinLength (${this.maxBinLength})`);
+        }
+        if (!this.hasRemaining(byteLength + headOffset)) {
+          throw MORE_DATA;
+        }
+        const offset = this.pos + headOffset;
+        const object = this.bytes.subarray(offset, offset + byteLength);
+        this.pos += headOffset + byteLength;
+        return object;
+      }
+      decodeExtension(size, headOffset) {
+        if (size > this.maxExtLength) {
+          throw new DecodeError_ts_1.DecodeError(`Max length exceeded: ext length (${size}) > maxExtLength (${this.maxExtLength})`);
+        }
+        const extType = this.view.getInt8(this.pos + headOffset);
+        const data = this.decodeBinary(
+          size,
+          headOffset + 1
+          /* extType */
+        );
+        return this.extensionCodec.decode(data, extType, this.context);
+      }
+      lookU8() {
+        return this.view.getUint8(this.pos);
+      }
+      lookU16() {
+        return this.view.getUint16(this.pos);
+      }
+      lookU32() {
+        return this.view.getUint32(this.pos);
+      }
+      readU8() {
+        const value = this.view.getUint8(this.pos);
+        this.pos++;
+        return value;
+      }
+      readI8() {
+        const value = this.view.getInt8(this.pos);
+        this.pos++;
+        return value;
+      }
+      readU16() {
+        const value = this.view.getUint16(this.pos);
+        this.pos += 2;
+        return value;
+      }
+      readI16() {
+        const value = this.view.getInt16(this.pos);
+        this.pos += 2;
+        return value;
+      }
+      readU32() {
+        const value = this.view.getUint32(this.pos);
+        this.pos += 4;
+        return value;
+      }
+      readI32() {
+        const value = this.view.getInt32(this.pos);
+        this.pos += 4;
+        return value;
+      }
+      readU64() {
+        const value = (0, int_ts_1.getUint64)(this.view, this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readI64() {
+        const value = (0, int_ts_1.getInt64)(this.view, this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readU64AsBigInt() {
+        const value = this.view.getBigUint64(this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readI64AsBigInt() {
+        const value = this.view.getBigInt64(this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readF32() {
+        const value = this.view.getFloat32(this.pos);
+        this.pos += 4;
+        return value;
+      }
+      readF64() {
+        const value = this.view.getFloat64(this.pos);
+        this.pos += 8;
+        return value;
+      }
+    };
+    exports.Decoder = Decoder;
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/decode.cjs
+var require_decode = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/decode.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decode = decode;
+    exports.decodeMulti = decodeMulti;
+    var Decoder_ts_1 = require_Decoder();
+    function decode(buffer, options) {
+      const decoder2 = new Decoder_ts_1.Decoder(options);
+      return decoder2.decode(buffer);
+    }
+    function decodeMulti(buffer, options) {
+      const decoder2 = new Decoder_ts_1.Decoder(options);
+      return decoder2.decodeMulti(buffer);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/stream.cjs
+var require_stream3 = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/stream.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isAsyncIterable = isAsyncIterable3;
+    exports.asyncIterableFromStream = asyncIterableFromStream;
+    exports.ensureAsyncIterable = ensureAsyncIterable;
+    function isAsyncIterable3(object) {
+      return object[Symbol.asyncIterator] != null;
+    }
+    async function* asyncIterableFromStream(stream) {
+      const reader = stream.getReader();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            return;
+          }
+          yield value;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+    function ensureAsyncIterable(streamLike) {
+      if (isAsyncIterable3(streamLike)) {
+        return streamLike;
+      } else {
+        return asyncIterableFromStream(streamLike);
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/decodeAsync.cjs
+var require_decodeAsync = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/decodeAsync.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decodeAsync = decodeAsync;
+    exports.decodeArrayStream = decodeArrayStream;
+    exports.decodeMultiStream = decodeMultiStream;
+    var Decoder_ts_1 = require_Decoder();
+    var stream_ts_1 = require_stream3();
+    async function decodeAsync(streamLike, options) {
+      const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+      const decoder2 = new Decoder_ts_1.Decoder(options);
+      return decoder2.decodeAsync(stream);
+    }
+    function decodeArrayStream(streamLike, options) {
+      const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+      const decoder2 = new Decoder_ts_1.Decoder(options);
+      return decoder2.decodeArrayStream(stream);
+    }
+    function decodeMultiStream(streamLike, options) {
+      const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+      const decoder2 = new Decoder_ts_1.Decoder(options);
+      return decoder2.decodeStream(stream);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/index.cjs
+var require_dist15 = __commonJS({
+  "../../node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/index.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decodeTimestampExtension = exports.encodeTimestampExtension = exports.decodeTimestampToTimeSpec = exports.encodeTimeSpecToTimestamp = exports.encodeDateToTimeSpec = exports.EXT_TIMESTAMP = exports.ExtData = exports.ExtensionCodec = exports.Encoder = exports.DecodeError = exports.Decoder = exports.decodeMultiStream = exports.decodeArrayStream = exports.decodeAsync = exports.decodeMulti = exports.decode = exports.encode = void 0;
+    var encode_ts_1 = require_encode();
+    Object.defineProperty(exports, "encode", { enumerable: true, get: function() {
+      return encode_ts_1.encode;
+    } });
+    var decode_ts_1 = require_decode();
+    Object.defineProperty(exports, "decode", { enumerable: true, get: function() {
+      return decode_ts_1.decode;
+    } });
+    Object.defineProperty(exports, "decodeMulti", { enumerable: true, get: function() {
+      return decode_ts_1.decodeMulti;
+    } });
+    var decodeAsync_ts_1 = require_decodeAsync();
+    Object.defineProperty(exports, "decodeAsync", { enumerable: true, get: function() {
+      return decodeAsync_ts_1.decodeAsync;
+    } });
+    Object.defineProperty(exports, "decodeArrayStream", { enumerable: true, get: function() {
+      return decodeAsync_ts_1.decodeArrayStream;
+    } });
+    Object.defineProperty(exports, "decodeMultiStream", { enumerable: true, get: function() {
+      return decodeAsync_ts_1.decodeMultiStream;
+    } });
+    var Decoder_ts_1 = require_Decoder();
+    Object.defineProperty(exports, "Decoder", { enumerable: true, get: function() {
+      return Decoder_ts_1.Decoder;
+    } });
+    var DecodeError_ts_1 = require_DecodeError();
+    Object.defineProperty(exports, "DecodeError", { enumerable: true, get: function() {
+      return DecodeError_ts_1.DecodeError;
+    } });
+    var Encoder_ts_1 = require_Encoder();
+    Object.defineProperty(exports, "Encoder", { enumerable: true, get: function() {
+      return Encoder_ts_1.Encoder;
+    } });
+    var ExtensionCodec_ts_1 = require_ExtensionCodec();
+    Object.defineProperty(exports, "ExtensionCodec", { enumerable: true, get: function() {
+      return ExtensionCodec_ts_1.ExtensionCodec;
+    } });
+    var ExtData_ts_1 = require_ExtData();
+    Object.defineProperty(exports, "ExtData", { enumerable: true, get: function() {
+      return ExtData_ts_1.ExtData;
+    } });
+    var timestamp_ts_1 = require_timestamp2();
+    Object.defineProperty(exports, "EXT_TIMESTAMP", { enumerable: true, get: function() {
+      return timestamp_ts_1.EXT_TIMESTAMP;
+    } });
+    Object.defineProperty(exports, "encodeDateToTimeSpec", { enumerable: true, get: function() {
+      return timestamp_ts_1.encodeDateToTimeSpec;
+    } });
+    Object.defineProperty(exports, "encodeTimeSpecToTimestamp", { enumerable: true, get: function() {
+      return timestamp_ts_1.encodeTimeSpecToTimestamp;
+    } });
+    Object.defineProperty(exports, "decodeTimestampToTimeSpec", { enumerable: true, get: function() {
+      return timestamp_ts_1.decodeTimestampToTimeSpec;
+    } });
+    Object.defineProperty(exports, "encodeTimestampExtension", { enumerable: true, get: function() {
+      return timestamp_ts_1.encodeTimestampExtension;
+    } });
+    Object.defineProperty(exports, "decodeTimestampExtension", { enumerable: true, get: function() {
+      return timestamp_ts_1.decodeTimestampExtension;
+    } });
+  }
+});
+
+// ../../node_modules/.pnpm/robot3@0.4.1/node_modules/robot3/dist/machine.js
+var require_machine = __commonJS({
+  "../../node_modules/.pnpm/robot3@0.4.1/node_modules/robot3/dist/machine.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function valueEnumerable(value) {
+      return { enumerable: true, value };
+    }
+    function valueEnumerableWritable(value) {
+      return { enumerable: true, writable: true, value };
+    }
+    var d = {};
+    var truthy = () => true;
+    var empty = () => ({});
+    var identity3 = (a) => a;
+    var callBoth = (par, fn, self2, args) => par.apply(self2, args) && fn.apply(self2, args);
+    var callForward = (par, fn, self2, [a, b]) => fn.call(self2, par.call(self2, a, b), b);
+    var create3 = (a, b) => Object.freeze(Object.create(a, b));
+    function stack(fns, def, caller) {
+      return fns.reduce((par, fn) => {
+        return function(...args) {
+          return caller(par, fn, this, args);
+        };
+      }, def);
+    }
+    function fnType(fn) {
+      return create3(this, { fn: valueEnumerable(fn) });
+    }
+    var reduceType = {};
+    var reduce = fnType.bind(reduceType);
+    var action = (fn) => reduce((ctx, ev) => !!~fn(ctx, ev) && ctx);
+    var guardType = {};
+    var guard = fnType.bind(guardType);
+    function filter4(Type, arr) {
+      return arr.filter((value) => Type.isPrototypeOf(value));
+    }
+    function makeTransition(from3, to, ...args) {
+      let guards = stack(filter4(guardType, args).map((t) => t.fn), truthy, callBoth);
+      let reducers = stack(filter4(reduceType, args).map((t) => t.fn), identity3, callForward);
+      return create3(this, {
+        from: valueEnumerable(from3),
+        to: valueEnumerable(to),
+        guards: valueEnumerable(guards),
+        reducers: valueEnumerable(reducers)
+      });
+    }
+    var transitionType = {};
+    var immediateType = {};
+    var transition = makeTransition.bind(transitionType);
+    var immediate = makeTransition.bind(immediateType, null);
+    function enterImmediate(machine2, service2, event) {
+      return transitionTo(service2, machine2, event, this.immediates) || machine2;
+    }
+    function transitionsToMap(transitions) {
+      let m = /* @__PURE__ */ new Map();
+      for (let t of transitions) {
+        if (!m.has(t.from)) m.set(t.from, []);
+        m.get(t.from).push(t);
+      }
+      return m;
+    }
+    var stateType = { enter: identity3 };
+    function state(...args) {
+      let transitions = filter4(transitionType, args);
+      let immediates = filter4(immediateType, args);
+      let desc = {
+        final: valueEnumerable(args.length === 0),
+        transitions: valueEnumerable(transitionsToMap(transitions))
+      };
+      if (immediates.length) {
+        desc.immediates = valueEnumerable(immediates);
+        desc.enter = valueEnumerable(enterImmediate);
+      }
+      return create3(stateType, desc);
+    }
+    var invokeFnType = {
+      enter(machine2, service2, event) {
+        let rn = this.fn.call(service2, service2.context, event);
+        if (machine.isPrototypeOf(rn))
+          return create3(invokeMachineType, {
+            machine: valueEnumerable(rn),
+            transitions: valueEnumerable(this.transitions)
+          }).enter(machine2, service2, event);
+        rn.then((data) => service2.send({ type: "done", data })).catch((error) => service2.send({ type: "error", error }));
+        return machine2;
+      }
+    };
+    var invokeMachineType = {
+      enter(machine2, service2, event) {
+        service2.child = interpret(this.machine, (s) => {
+          service2.onChange(s);
+          if (service2.child == s && s.machine.state.value.final) {
+            delete service2.child;
+            service2.send({ type: "done", data: s.context });
+          }
+        }, service2.context, event);
+        if (service2.child.machine.state.value.final) {
+          let data = service2.child.context;
+          delete service2.child;
+          return transitionTo(service2, machine2, { type: "done", data }, this.transitions.get("done"));
+        }
+        return machine2;
+      }
+    };
+    function invoke(fn, ...transitions) {
+      let t = valueEnumerable(transitionsToMap(transitions));
+      return machine.isPrototypeOf(fn) ? create3(invokeMachineType, {
+        machine: valueEnumerable(fn),
+        transitions: t
+      }) : create3(invokeFnType, {
+        fn: valueEnumerable(fn),
+        transitions: t
+      });
+    }
+    var machine = {
+      get state() {
+        return {
+          name: this.current,
+          value: this.states[this.current]
+        };
+      }
+    };
+    function createMachine(current, states, contextFn = empty) {
+      if (typeof current !== "string") {
+        contextFn = states || empty;
+        states = current;
+        current = Object.keys(states)[0];
+      }
+      if (d._create) d._create(current, states);
+      return create3(machine, {
+        context: valueEnumerable(contextFn),
+        current: valueEnumerable(current),
+        states: valueEnumerable(states)
+      });
+    }
+    function transitionTo(service2, machine2, fromEvent3, candidates) {
+      let { context: context3 } = service2;
+      for (let { to, guards, reducers } of candidates) {
+        if (guards(context3, fromEvent3)) {
+          service2.context = reducers.call(service2, context3, fromEvent3);
+          let original = machine2.original || machine2;
+          let newMachine = create3(original, {
+            current: valueEnumerable(to),
+            original: { value: original }
+          });
+          if (d._onEnter) d._onEnter(machine2, to, service2.context, context3, fromEvent3);
+          let state2 = newMachine.state.value;
+          return state2.enter(newMachine, service2, fromEvent3);
+        }
+      }
+    }
+    function send(service2, event) {
+      let eventName = event.type || event;
+      let { machine: machine2 } = service2;
+      let { value: state2, name: currentStateName } = machine2.state;
+      if (state2.transitions.has(eventName)) {
+        return transitionTo(service2, machine2, event, state2.transitions.get(eventName)) || machine2;
+      } else {
+        if (d._send) d._send(eventName, currentStateName);
+      }
+      return machine2;
+    }
+    var service = {
+      send(event) {
+        this.machine = send(this, event);
+        this.onChange(this);
+      }
+    };
+    function interpret(machine2, onChange, initialContext, event) {
+      let s = Object.create(service, {
+        machine: valueEnumerableWritable(machine2),
+        context: valueEnumerableWritable(machine2.context(initialContext, event)),
+        onChange: valueEnumerable(onChange)
+      });
+      s.send = s.send.bind(s);
+      s.machine = s.machine.state.value.enter(s.machine, s, event);
+      return s;
+    }
+    exports.action = action;
+    exports.createMachine = createMachine;
+    exports.d = d;
+    exports.guard = guard;
+    exports.immediate = immediate;
+    exports.interpret = interpret;
+    exports.invoke = invoke;
+    exports.reduce = reduce;
+    exports.state = state;
+    exports.transition = transition;
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/realtime.js
+var require_realtime = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/realtime.js"(exports) {
+    "use strict";
+    var __awaiter4 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve44) {
+          resolve44(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve44, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve44(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createRealtimeClient = createRealtimeClient;
+    var msgpack_1 = require_dist15();
+    var robot3_1 = require_machine();
+    var auth_1 = require_auth();
+    var response_1 = require_response();
+    var runtime_1 = require_runtime3();
+    var utils_1 = require_utils4();
+    var initialState = () => ({
+      enqueuedMessage: void 0
+    });
+    function hasToken(context3) {
+      return context3.token !== void 0;
+    }
+    function noToken(context3) {
+      return !hasToken(context3);
+    }
+    function enqueueMessage(context3, event) {
+      return Object.assign(Object.assign({}, context3), { enqueuedMessage: event.message });
+    }
+    function closeConnection(context3) {
+      if (context3.websocket && context3.websocket.readyState === WebSocket.OPEN) {
+        context3.websocket.close();
+      }
+      return Object.assign(Object.assign({}, context3), { websocket: void 0 });
+    }
+    function sendMessage(context3, event) {
+      if (context3.websocket && context3.websocket.readyState === WebSocket.OPEN) {
+        if (event.message instanceof Uint8Array) {
+          context3.websocket.send(event.message);
+        } else if (typeof event.message === "string") {
+          context3.websocket.send(event.message);
+        } else {
+          context3.websocket.send((0, msgpack_1.encode)(event.message));
+        }
+        return Object.assign(Object.assign({}, context3), { enqueuedMessage: void 0 });
+      }
+      return Object.assign(Object.assign({}, context3), { enqueuedMessage: event.message });
+    }
+    function expireToken(context3) {
+      return Object.assign(Object.assign({}, context3), { token: void 0 });
+    }
+    function setToken(context3, event) {
+      return Object.assign(Object.assign({}, context3), { token: event.token });
+    }
+    function connectionEstablished(context3, event) {
+      return Object.assign(Object.assign({}, context3), { websocket: event.websocket });
+    }
+    var connectionStateMachine = (0, robot3_1.createMachine)("idle", {
+      idle: (0, robot3_1.state)((0, robot3_1.transition)("send", "connecting", (0, robot3_1.reduce)(enqueueMessage)), (0, robot3_1.transition)("close", "idle", (0, robot3_1.reduce)(closeConnection))),
+      connecting: (0, robot3_1.state)((0, robot3_1.transition)("connecting", "connecting"), (0, robot3_1.transition)("connected", "active", (0, robot3_1.reduce)(connectionEstablished)), (0, robot3_1.transition)("connectionClosed", "idle", (0, robot3_1.reduce)(closeConnection)), (0, robot3_1.transition)("send", "connecting", (0, robot3_1.reduce)(enqueueMessage)), (0, robot3_1.transition)("close", "idle", (0, robot3_1.reduce)(closeConnection)), (0, robot3_1.immediate)("authRequired", (0, robot3_1.guard)(noToken))),
+      authRequired: (0, robot3_1.state)((0, robot3_1.transition)("initiateAuth", "authInProgress"), (0, robot3_1.transition)("send", "authRequired", (0, robot3_1.reduce)(enqueueMessage)), (0, robot3_1.transition)("close", "idle", (0, robot3_1.reduce)(closeConnection))),
+      authInProgress: (0, robot3_1.state)((0, robot3_1.transition)("authenticated", "connecting", (0, robot3_1.reduce)(setToken)), (0, robot3_1.transition)("unauthorized", "idle", (0, robot3_1.reduce)(expireToken), (0, robot3_1.reduce)(closeConnection)), (0, robot3_1.transition)("send", "authInProgress", (0, robot3_1.reduce)(enqueueMessage)), (0, robot3_1.transition)("close", "idle", (0, robot3_1.reduce)(closeConnection))),
+      active: (0, robot3_1.state)((0, robot3_1.transition)("send", "active", (0, robot3_1.reduce)(sendMessage)), (0, robot3_1.transition)("authenticated", "active", (0, robot3_1.reduce)(setToken)), (0, robot3_1.transition)("unauthorized", "idle", (0, robot3_1.reduce)(expireToken)), (0, robot3_1.transition)("connectionClosed", "idle", (0, robot3_1.reduce)(expireToken), (0, robot3_1.reduce)(closeConnection)), (0, robot3_1.transition)("close", "idle", (0, robot3_1.reduce)(expireToken), (0, robot3_1.reduce)(closeConnection)))
+    }, initialState);
+    function buildRealtimeUrl(app, { token, maxBuffering, path: path14 }) {
+      var _a7;
+      if (maxBuffering !== void 0 && (maxBuffering < 1 || maxBuffering > 60)) {
+        throw new Error("The `maxBuffering` must be between 1 and 60 (inclusive)");
+      }
+      const queryParams = new URLSearchParams({
+        fal_jwt_token: token
+      });
+      if (maxBuffering !== void 0) {
+        queryParams.set("max_buffering", maxBuffering.toFixed(0));
+      }
+      const appId = (0, utils_1.ensureEndpointIdFormat)(app);
+      const resolvedPath = (_a7 = (0, utils_1.resolveEndpointPath)(app, path14, "/realtime")) !== null && _a7 !== void 0 ? _a7 : "";
+      return `wss://fal.run/${appId}${resolvedPath}?${queryParams.toString()}`;
+    }
+    var DEFAULT_THROTTLE_INTERVAL = 128;
+    function isUnauthorizedError(message) {
+      return message["status"] === "error" && message["error"] === "Unauthorized";
+    }
+    var WebSocketErrorCodes = {
+      NORMAL_CLOSURE: 1e3,
+      GOING_AWAY: 1001
+    };
+    var connectionCache = /* @__PURE__ */ new Map();
+    var connectionCallbacks = /* @__PURE__ */ new Map();
+    function reuseInterpreter(key2, throttleInterval, onChange) {
+      if (!connectionCache.has(key2)) {
+        const service = (0, robot3_1.interpret)(connectionStateMachine, onChange);
+        connectionCache.set(key2, {
+          service,
+          throttledSend: throttleInterval > 0 ? (0, utils_1.throttle)(service.send, throttleInterval, true) : service.send
+        });
+      }
+      return connectionCache.get(key2);
+    }
+    var noop3 = () => {
+    };
+    var NoOpConnection = {
+      send: noop3,
+      close: noop3
+    };
+    function isSuccessfulResult(data) {
+      return data.status !== "error" && data.type !== "x-fal-message" && !isFalErrorResult(data);
+    }
+    function isFalErrorResult(data) {
+      return data.type === "x-fal-error";
+    }
+    function decodeRealtimeMessage(data) {
+      return __awaiter4(this, void 0, void 0, function* () {
+        if (typeof data === "string") {
+          return JSON.parse(data);
+        }
+        const toUint8Array = (value) => __awaiter4(this, void 0, void 0, function* () {
+          if (value instanceof Uint8Array) {
+            return value;
+          }
+          if (value instanceof Blob) {
+            return new Uint8Array(yield value.arrayBuffer());
+          }
+          return new Uint8Array(value);
+        });
+        if (data instanceof ArrayBuffer || data instanceof Uint8Array) {
+          return (0, msgpack_1.decode)(yield toUint8Array(data));
+        }
+        if (data instanceof Blob) {
+          return (0, msgpack_1.decode)(yield toUint8Array(data));
+        }
+        return data;
+      });
+    }
+    function encodeRealtimeMessage(input3) {
+      if (input3 instanceof Uint8Array) {
+        return input3;
+      }
+      if (typeof input3 === "string") {
+        return (0, msgpack_1.encode)(input3);
+      }
+      return (0, msgpack_1.encode)(input3);
+    }
+    function handleRealtimeMessage({ data, decodeMessage, onResult, onError, send }) {
+      const handleDecoded = (decoded) => {
+        if (isUnauthorizedError(decoded)) {
+          send({
+            type: "unauthorized",
+            error: new Error("Unauthorized")
+          });
+          return;
+        }
+        if (isSuccessfulResult(decoded)) {
+          onResult(decoded);
+          return;
+        }
+        if (isFalErrorResult(decoded)) {
+          if (decoded.error === "TIMEOUT") {
+            return;
+          }
+          onError(new response_1.ApiError({
+            message: `${decoded.error}: ${decoded.reason}`,
+            // TODO better error status code
+            status: 400,
+            body: decoded
+          }));
+          return;
+        }
+      };
+      Promise.resolve(decodeMessage ? decodeMessage(data) : data).then(handleDecoded).catch((error) => {
+        var _a7;
+        onError(new response_1.ApiError({
+          message: (_a7 = error === null || error === void 0 ? void 0 : error.message) !== null && _a7 !== void 0 ? _a7 : "Failed to decode realtime message",
+          status: 400
+        }));
+      });
+    }
+    function createRealtimeClient({ config: config4 }) {
+      return {
+        connect(app, handler4) {
+          const {
+            // if running on React in the server, set clientOnly to true by default
+            clientOnly = (0, utils_1.isReact)() && !(0, runtime_1.isBrowser)(),
+            connectionKey = crypto.randomUUID(),
+            maxBuffering,
+            path: path14,
+            throttleInterval = DEFAULT_THROTTLE_INTERVAL,
+            encodeMessage: encodeMessageOverride,
+            decodeMessage: decodeMessageOverride,
+            tokenProvider,
+            tokenExpirationSeconds
+          } = handler4;
+          if (clientOnly && !(0, runtime_1.isBrowser)()) {
+            return NoOpConnection;
+          }
+          const encodeMessageFn = encodeMessageOverride !== null && encodeMessageOverride !== void 0 ? encodeMessageOverride : ((input3) => encodeRealtimeMessage(input3));
+          const decodeMessageFn = decodeMessageOverride !== null && decodeMessageOverride !== void 0 ? decodeMessageOverride : ((data) => decodeRealtimeMessage(data));
+          let previousState;
+          let latestEnqueuedMessage;
+          let tokenRefreshTimer;
+          let tokenRefreshGeneration = 0;
+          connectionCallbacks.set(connectionKey, {
+            decodeMessage: decodeMessageFn,
+            onError: handler4.onError,
+            onResult: handler4.onResult
+          });
+          const getCallbacks = () => connectionCallbacks.get(connectionKey);
+          const stateMachine = reuseInterpreter(connectionKey, throttleInterval, ({ context: context3, machine, send: send2 }) => {
+            var _a7;
+            const { enqueuedMessage, token, websocket } = context3;
+            latestEnqueuedMessage = enqueuedMessage;
+            if (machine.current === "active" && enqueuedMessage && (websocket === null || websocket === void 0 ? void 0 : websocket.readyState) === WebSocket.OPEN) {
+              send2({ type: "send", message: enqueuedMessage });
+            }
+            if (machine.current === "authRequired" && token === void 0 && previousState !== machine.current) {
+              send2({ type: "initiateAuth" });
+              tokenRefreshGeneration++;
+              const generation = tokenRefreshGeneration;
+              const appId = (0, utils_1.ensureEndpointIdFormat)(app);
+              const resolvedPath = (_a7 = (0, utils_1.resolveEndpointPath)(app, path14, "/realtime")) !== null && _a7 !== void 0 ? _a7 : "";
+              const fetchToken = tokenProvider ? () => tokenProvider(`${appId}${resolvedPath}`) : () => {
+                console.warn("[fal.realtime] Using the default token provider is deprecated. Please provide a `tokenProvider` function to `fal.realtime.connect()`. See https://docs.fal.ai/model-apis/client#client-side-usage-with-token-provider for more information.");
+                return (0, auth_1.getTemporaryAuthToken)(app, config4);
+              };
+              const effectiveExpiration = tokenProvider ? tokenExpirationSeconds : auth_1.TOKEN_EXPIRATION_SECONDS;
+              const scheduleTokenRefresh = effectiveExpiration !== void 0 ? () => {
+                clearTimeout(tokenRefreshTimer);
+                const refreshMs = Math.round(effectiveExpiration * 0.9 * 1e3);
+                tokenRefreshTimer = setTimeout(() => {
+                  if (generation !== tokenRefreshGeneration) {
+                    return;
+                  }
+                  fetchToken().then((newToken) => {
+                    if (generation !== tokenRefreshGeneration) {
+                      return;
+                    }
+                    queueMicrotask(() => {
+                      send2({ type: "authenticated", token: newToken });
+                    });
+                    scheduleTokenRefresh();
+                  }).catch(() => {
+                    if (generation !== tokenRefreshGeneration) {
+                      return;
+                    }
+                    const retryMs = Math.round(effectiveExpiration * 0.05 * 1e3);
+                    tokenRefreshTimer = setTimeout(() => {
+                      scheduleTokenRefresh();
+                    }, retryMs);
+                  });
+                }, refreshMs);
+              } : noop3;
+              fetchToken().then((token2) => {
+                queueMicrotask(() => {
+                  send2({ type: "authenticated", token: token2 });
+                });
+                scheduleTokenRefresh();
+              }).catch((error) => {
+                queueMicrotask(() => {
+                  send2({ type: "unauthorized", error });
+                });
+              });
+            }
+            if (machine.current === "connecting" && previousState !== machine.current && token !== void 0) {
+              const ws = new WebSocket(buildRealtimeUrl(app, { token, maxBuffering, path: path14 }));
+              ws.onopen = () => {
+                var _a8, _b3;
+                send2({ type: "connected", websocket: ws });
+                const queued = (_b3 = (_a8 = stateMachine.service.context) === null || _a8 === void 0 ? void 0 : _a8.enqueuedMessage) !== null && _b3 !== void 0 ? _b3 : latestEnqueuedMessage;
+                if (queued) {
+                  ws.send(encodeMessageFn(queued));
+                  stateMachine.service.context = Object.assign(Object.assign({}, stateMachine.service.context), { enqueuedMessage: void 0 });
+                }
+              };
+              ws.onclose = (event) => {
+                if (event.code !== WebSocketErrorCodes.NORMAL_CLOSURE) {
+                  const { onError = noop3 } = getCallbacks();
+                  onError(new response_1.ApiError({
+                    message: `Error closing the connection: ${event.reason}`,
+                    status: event.code
+                  }));
+                }
+                send2({ type: "connectionClosed", code: event.code });
+              };
+              ws.onerror = (event) => {
+                const { onError = noop3 } = getCallbacks();
+                onError(new response_1.ApiError({ message: "Unknown error", status: 500 }));
+              };
+              ws.onmessage = (event) => {
+                const { decodeMessage = decodeMessageFn, onResult, onError = noop3 } = getCallbacks();
+                handleRealtimeMessage({
+                  data: event.data,
+                  decodeMessage,
+                  onResult,
+                  onError,
+                  send: send2
+                });
+              };
+            }
+            if (previousState === "active" && machine.current !== "active") {
+              clearTimeout(tokenRefreshTimer);
+              tokenRefreshTimer = void 0;
+            }
+            previousState = machine.current;
+          });
+          const send = (input3) => {
+            stateMachine.throttledSend({
+              type: "send",
+              message: encodeMessageFn(input3)
+            });
+          };
+          const close = () => {
+            stateMachine.service.send({ type: "close" });
+          };
+          return {
+            send,
+            close
+          };
+        }
+      };
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/client.js
+var require_client = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/client.js"(exports) {
+    "use strict";
+    var __awaiter4 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve44) {
+          resolve44(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve44, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve44(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createFalClient = createFalClient2;
+    var config_1 = require_config();
+    var headers_1 = require_headers3();
+    var queue_1 = require_queue();
+    var realtime_1 = require_realtime();
+    var request_1 = require_request();
+    var response_1 = require_response();
+    var storage_1 = require_storage();
+    var streaming_1 = require_streaming();
+    function createFalClient2(userConfig = {}) {
+      const config4 = (0, config_1.createConfig)(userConfig);
+      const storage = (0, storage_1.createStorageClient)({ config: config4 });
+      const queue = (0, queue_1.createQueueClient)({ config: config4, storage });
+      const streaming = (0, streaming_1.createStreamingClient)({ config: config4, storage });
+      const realtime = (0, realtime_1.createRealtimeClient)({ config: config4 });
+      return {
+        queue,
+        realtime,
+        storage,
+        streaming,
+        stream: streaming.stream,
+        run(endpointId_1) {
+          return __awaiter4(this, arguments, void 0, function* (endpointId, options = {}) {
+            const input3 = options.input ? yield storage.transformInput(options.input) : void 0;
+            return (0, request_1.dispatchRequest)({
+              method: options.method,
+              targetUrl: (0, request_1.buildUrl)(endpointId, options),
+              input: input3,
+              // TODO: consider supporting custom headers in fal.run() as well
+              headers: Object.assign(Object.assign({}, (0, storage_1.buildObjectLifecycleHeaders)(options.storageSettings)), (0, headers_1.buildTimeoutHeaders)(options.startTimeout)),
+              config: Object.assign(Object.assign({}, config4), { responseHandler: response_1.resultResponseHandler }),
+              options: {
+                signal: options.abortSignal,
+                retry: {
+                  maxRetries: 3,
+                  baseDelay: 500,
+                  maxDelay: 15e3
+                }
+              }
+            });
+          });
+        },
+        subscribe: (endpointId, options) => __awaiter4(this, void 0, void 0, function* () {
+          const { request_id: requestId } = yield queue.submit(endpointId, options);
+          if (options.onEnqueue) {
+            options.onEnqueue(requestId);
+          }
+          yield queue.subscribeToStatus(endpointId, Object.assign({ requestId }, options));
+          return queue.result(endpointId, { requestId });
+        })
+      };
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/types/common.js
+var require_common6 = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/types/common.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isQueueStatus = isQueueStatus;
+    exports.isCompletedQueueStatus = isCompletedQueueStatus;
+    function isQueueStatus(obj) {
+      return obj && obj.status && obj.response_url;
+    }
+    function isCompletedQueueStatus(obj) {
+      return isQueueStatus(obj) && obj.status === "COMPLETED";
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/index.js
+var require_src3 = __commonJS({
+  "../../node_modules/.pnpm/@fal-ai+client@1.10.0/node_modules/@fal-ai/client/src/index.js"(exports) {
+    "use strict";
+    var __createBinding3 = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar3 = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding3(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.fal = exports.parseEndpointId = exports.isRetryableError = exports.ValidationError = exports.ApiError = exports.withProxy = exports.withMiddleware = exports.createFalClient = void 0;
+    var client_1 = require_client();
+    var client_2 = require_client();
+    Object.defineProperty(exports, "createFalClient", { enumerable: true, get: function() {
+      return client_2.createFalClient;
+    } });
+    var middleware_1 = require_middleware();
+    Object.defineProperty(exports, "withMiddleware", { enumerable: true, get: function() {
+      return middleware_1.withMiddleware;
+    } });
+    Object.defineProperty(exports, "withProxy", { enumerable: true, get: function() {
+      return middleware_1.withProxy;
+    } });
+    var response_1 = require_response();
+    Object.defineProperty(exports, "ApiError", { enumerable: true, get: function() {
+      return response_1.ApiError;
+    } });
+    Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
+      return response_1.ValidationError;
+    } });
+    var retry_1 = require_retry();
+    Object.defineProperty(exports, "isRetryableError", { enumerable: true, get: function() {
+      return retry_1.isRetryableError;
+    } });
+    __exportStar3(require_common6(), exports);
+    var utils_1 = require_utils4();
+    Object.defineProperty(exports, "parseEndpointId", { enumerable: true, get: function() {
+      return utils_1.parseEndpointId;
+    } });
+    exports.fal = (function createSingletonFalClient() {
+      let currentInstance = (0, client_1.createFalClient)();
+      return {
+        config(config4) {
+          currentInstance = (0, client_1.createFalClient)(config4);
+        },
+        get queue() {
+          return currentInstance.queue;
+        },
+        get realtime() {
+          return currentInstance.realtime;
+        },
+        get storage() {
+          return currentInstance.storage;
+        },
+        get streaming() {
+          return currentInstance.streaming;
+        },
+        run(id, options) {
+          return currentInstance.run(id, options);
+        },
+        subscribe(endpointId, options) {
+          return currentInstance.subscribe(endpointId, options);
+        },
+        stream(endpointId, options) {
+          return currentInstance.stream(endpointId, options);
+        }
+      };
+    })();
+  }
+});
+
+// ../ai-providers/dist/fal/FalProvider.js
+function pickReferenceImageUrl(input3) {
+  if (typeof input3 !== "string")
+    return void 0;
+  if (input3.startsWith("http://") || input3.startsWith("https://"))
+    return input3;
+  return void 0;
+}
+function normaliseAspect(value) {
+  if (!value)
+    return "auto";
+  return VALID_ASPECTS.includes(value) ? value : "auto";
+}
+function normaliseResolution(value) {
+  if (!value)
+    return "720p";
+  if (VALID_RESOLUTIONS.includes(value)) {
+    return value;
+  }
+  if (value === "4k")
+    return "1080p";
+  return "720p";
+}
+function normaliseDuration(value) {
+  if (typeof value !== "number")
+    return "auto";
+  if (!Number.isFinite(value))
+    return "auto";
+  return Math.max(4, Math.min(15, Math.round(value)));
+}
+var import_client, ENDPOINT_TEXT_TO_VIDEO, ENDPOINT_IMAGE_TO_VIDEO, DEFAULT_VARIANT, VALID_RESOLUTIONS, VALID_ASPECTS, FalProvider, falProvider;
+var init_FalProvider = __esm({
+  "../ai-providers/dist/fal/FalProvider.js"() {
+    "use strict";
+    import_client = __toESM(require_src3(), 1);
+    ENDPOINT_TEXT_TO_VIDEO = {
+      "seedance-2.0": "bytedance/seedance-2.0/text-to-video",
+      "seedance-2.0-fast": "bytedance/seedance-2.0/fast/text-to-video"
+    };
+    ENDPOINT_IMAGE_TO_VIDEO = {
+      "seedance-2.0": "bytedance/seedance-2.0/image-to-video",
+      "seedance-2.0-fast": "bytedance/seedance-2.0/fast/image-to-video"
+    };
+    DEFAULT_VARIANT = "seedance-2.0";
+    VALID_RESOLUTIONS = ["480p", "720p", "1080p"];
+    VALID_ASPECTS = ["21:9", "16:9", "4:3", "1:1", "3:4", "9:16", "auto"];
+    FalProvider = class {
+      constructor() {
+        this.id = "fal";
+        this.name = "fal.ai (Seedance 2.0)";
+        this.description = "fal.ai hosting ByteDance Seedance 2.0 \u2014 Artificial Analysis #2 on both text-to-video and image-to-video leaderboards";
+        this.capabilities = ["text-to-video", "image-to-video"];
+        this.iconUrl = "/icons/fal.svg";
+        this.isAvailable = true;
+      }
+      async initialize(config4) {
+        this.apiKey = config4.apiKey;
+        if (!this.apiKey)
+          return;
+        this.client = (0, import_client.createFalClient)({ credentials: this.apiKey });
+      }
+      isConfigured() {
+        return !!this.apiKey && !!this.client;
+      }
+      /**
+       * Generate a video from a text prompt — or from a reference image when
+       * `options.referenceImage` is set (treated as an image-to-video
+       * request, routed to a different endpoint).
+       *
+       * fal.subscribe blocks until the final result is available. It also
+       * surfaces queue / log events through `onQueueUpdate`, which we drop
+       * silently for now — the CLI's existing spinner is the user-facing
+       * progress UI.
+       */
+      async generateVideo(prompt3, options) {
+        if (!this.client) {
+          return {
+            id: "",
+            status: "failed",
+            error: "fal.ai API key not configured. Set FAL_KEY in .env."
+          };
+        }
+        const variant = options?.model ?? DEFAULT_VARIANT;
+        if (!Object.hasOwn(ENDPOINT_TEXT_TO_VIDEO, variant)) {
+          return {
+            id: "",
+            status: "failed",
+            error: `Unknown Seedance variant: ${variant}. Valid: ${Object.keys(ENDPOINT_TEXT_TO_VIDEO).join(", ")}.`
+          };
+        }
+        const referenceImage = pickReferenceImageUrl(options?.referenceImage);
+        const isImageToVideo = !!referenceImage;
+        const endpointId = isImageToVideo ? ENDPOINT_IMAGE_TO_VIDEO[variant] : ENDPOINT_TEXT_TO_VIDEO[variant];
+        const aspect = normaliseAspect(options?.aspectRatio);
+        const resolution = normaliseResolution(options?.resolution);
+        const duration = normaliseDuration(options?.duration);
+        const input3 = {
+          prompt: prompt3,
+          aspect_ratio: aspect,
+          resolution,
+          duration
+        };
+        if (referenceImage)
+          input3.image_url = referenceImage;
+        if (options?.negativePrompt)
+          input3.negative_prompt = options.negativePrompt;
+        if (typeof options?.seed === "number")
+          input3.seed = options.seed;
+        if (options?.lastFrame)
+          input3.end_image_url = options.lastFrame;
+        try {
+          const out = await this.client.subscribe(endpointId, { input: input3, logs: false });
+          const data = out?.data ?? {};
+          const url = data.video?.url;
+          if (!url) {
+            return {
+              id: typeof out?.requestId === "string" ? out.requestId : "",
+              status: "failed",
+              error: "fal.subscribe returned without a video URL"
+            };
+          }
+          return {
+            id: typeof out?.requestId === "string" ? out.requestId : "",
+            status: "completed",
+            videoUrl: url,
+            progress: 100
+          };
+        } catch (err) {
+          return {
+            id: "",
+            status: "failed",
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      }
+    };
+    falProvider = new FalProvider();
+  }
+});
+
+// ../ai-providers/dist/fal/index.js
+var init_fal = __esm({
+  "../ai-providers/dist/fal/index.js"() {
+    "use strict";
+    init_FalProvider();
+  }
+});
+
 // ../ai-providers/dist/replicate/ReplicateProvider.js
 var ReplicateProvider, replicateProvider;
 var init_ReplicateProvider = __esm({
@@ -434842,6 +439104,7 @@ var dist_exports2 = {};
 __export(dist_exports2, {
   ClaudeProvider: () => ClaudeProvider,
   ElevenLabsProvider: () => ElevenLabsProvider,
+  FalProvider: () => FalProvider,
   GeminiProvider: () => GeminiProvider,
   GrokProvider: () => GrokProvider,
   KNOWN_VOICES: () => KNOWN_VOICES,
@@ -434857,6 +439120,7 @@ __export(dist_exports2, {
   WhisperProvider: () => WhisperProvider,
   claudeProvider: () => claudeProvider,
   elevenLabsProvider: () => elevenLabsProvider,
+  falProvider: () => falProvider,
   geminiProvider: () => geminiProvider,
   getBestProviderForCapability: () => getBestProviderForCapability,
   grokProvider: () => grokProvider,
@@ -434887,12 +439151,13 @@ var init_dist2 = __esm({
     init_runway();
     init_kling();
     init_grok();
+    init_fal();
     init_replicate();
   }
 });
 
 // ../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json
-var require_package3 = __commonJS({
+var require_package4 = __commonJS({
   "../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json"(exports, module) {
     module.exports = {
       name: "dotenv",
@@ -434966,7 +439231,7 @@ var require_main4 = __commonJS({
     var path14 = __require("path");
     var os11 = __require("os");
     var crypto3 = __require("crypto");
-    var packageJson = require_package3();
+    var packageJson = require_package4();
     var version = packageJson.version;
     var TIPS = [
       "\u{1F510} encrypt with Dotenvx: https://dotenvx.com",
@@ -437685,7 +441950,7 @@ var require_float2 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/dist/schema/core/int.js
-var require_int2 = __commonJS({
+var require_int3 = __commonJS({
   "../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/dist/schema/core/int.js"(exports) {
     "use strict";
     var stringifyNumber = require_stringifyNumber();
@@ -437739,7 +442004,7 @@ var require_schema2 = __commonJS({
     var string = require_string();
     var bool = require_bool2();
     var float = require_float2();
-    var int = require_int2();
+    var int = require_int3();
     var schema = [
       map3.map,
       seq.seq,
@@ -438128,7 +442393,7 @@ var require_float3 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/dist/schema/yaml-1.1/int.js
-var require_int3 = __commonJS({
+var require_int4 = __commonJS({
   "../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/dist/schema/yaml-1.1/int.js"(exports) {
     "use strict";
     var stringifyNumber = require_stringifyNumber();
@@ -438296,7 +442561,7 @@ var require_set2 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/dist/schema/yaml-1.1/timestamp.js
-var require_timestamp2 = __commonJS({
+var require_timestamp3 = __commonJS({
   "../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/dist/schema/yaml-1.1/timestamp.js"(exports) {
     "use strict";
     var stringifyNumber = require_stringifyNumber();
@@ -438394,12 +442659,12 @@ var require_schema4 = __commonJS({
     var binary = require_binary2();
     var bool = require_bool3();
     var float = require_float3();
-    var int = require_int3();
+    var int = require_int4();
     var merge3 = require_merge3();
     var omap = require_omap2();
     var pairs = require_pairs2();
     var set = require_set2();
-    var timestamp = require_timestamp2();
+    var timestamp = require_timestamp3();
     var schema = [
       map3.map,
       seq.seq,
@@ -438437,7 +442702,7 @@ var require_tags = __commonJS({
     var string = require_string();
     var bool = require_bool2();
     var float = require_float2();
-    var int = require_int2();
+    var int = require_int3();
     var schema = require_schema2();
     var schema$1 = require_schema3();
     var binary = require_binary2();
@@ -438446,7 +442711,7 @@ var require_tags = __commonJS({
     var pairs = require_pairs2();
     var schema$2 = require_schema4();
     var set = require_set2();
-    var timestamp = require_timestamp2();
+    var timestamp = require_timestamp3();
     var schemas = /* @__PURE__ */ new Map([
       ["core", schema.schema],
       ["failsafe", [map3.map, seq.seq, string.string]],
@@ -442526,7 +446791,7 @@ var require_public_api = __commonJS({
 });
 
 // ../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/dist/index.js
-var require_dist14 = __commonJS({
+var require_dist16 = __commonJS({
   "../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/dist/index.js"(exports) {
     "use strict";
     var composer = require_composer();
@@ -442650,7 +446915,7 @@ var import_yaml, CONFIG_DIR, CONFIG_PATH;
 var init_config = __esm({
   "../cli/src/config/index.ts"() {
     "use strict";
-    import_yaml = __toESM(require_dist14(), 1);
+    import_yaml = __toESM(require_dist16(), 1);
     init_schema();
     init_schema();
     CONFIG_DIR = resolve14(homedir4(), ".vibeframe");
@@ -446388,7 +450653,7 @@ var import_yaml2, ASPECT_DIMS;
 var init_scene_project = __esm({
   "../cli/src/commands/_shared/scene-project.ts"() {
     "use strict";
-    import_yaml2 = __toESM(require_dist14(), 1);
+    import_yaml2 = __toESM(require_dist16(), 1);
     ASPECT_DIMS = {
       "16:9": { width: 1920, height: 1080 },
       "9:16": { width: 1080, height: 1920 },
@@ -448329,7 +452594,7 @@ var import_yaml3, DEFAULT_VIDEO_RETRIES, RETRY_DELAY_MS;
 var init_ai_script_pipeline = __esm({
   "../cli/src/commands/ai-script-pipeline.ts"() {
     "use strict";
-    import_yaml3 = __toESM(require_dist14(), 1);
+    import_yaml3 = __toESM(require_dist16(), 1);
     init_source();
     init_dist2();
     init_api_key();
@@ -450366,6 +454631,7 @@ var init_provider_resolver = __esm({
       { name: "grok", envVar: "XAI_API_KEY", label: "Grok" }
     ];
     VIDEO_PROVIDERS = [
+      { name: "fal", envVar: "FAL_KEY", label: "fal.ai (Seedance 2.0)" },
       { name: "grok", envVar: "XAI_API_KEY", label: "Grok" },
       { name: "veo", envVar: "GOOGLE_API_KEY", label: "Veo" },
       { name: "kling", envVar: "KLING_API_KEY", label: "Kling" },
@@ -451180,7 +455446,7 @@ Examples:
         exitWithError(apiError(`Image generation failed: ${error.message}`));
       }
     });
-    generateCommand.command("video").alias("vid").description("Generate video using AI (Kling, Runway, Veo, or Grok)").argument("[prompt]", "Text prompt describing the video (interactive if omitted)").option("-p, --provider <provider>", "Provider: grok (default), kling, runway, veo", "grok").option("-k, --api-key <key>", "API key (or set XAI_API_KEY / RUNWAY_API_SECRET / KLING_API_KEY / GOOGLE_API_KEY env)").option("-o, --output <path>", "Output file path (downloads video)").option("-i, --image <path>", "Reference image for image-to-video").option("-d, --duration <sec>", "Duration: 5 or 10 seconds", "5").option("-r, --ratio <ratio>", "Aspect ratio: 16:9, 9:16, or 1:1 (auto-detected from image if omitted)").option("-s, --seed <number>", "Random seed for reproducibility (Runway only)").option("-m, --mode <mode>", "Generation mode: std or pro (Kling only)", "std").option("-n, --negative <prompt>", "Negative prompt - what to avoid (Kling/Veo)").option("--resolution <res>", "Video resolution: 720p, 1080p, 4k (Veo only)").option("--last-frame <path>", "Last frame image for frame interpolation (Veo only)").option("--ref-images <paths...>", "Reference images for character consistency (Veo 3.1 only, max 3)").option("--person <mode>", "Person generation: allow_all, allow_adult (Veo only)").option("--veo-model <model>", "Veo model: 3.0, 3.1, 3.1-fast (default: 3.1-fast)", "3.1-fast").option("--runway-model <model>", "Runway model: gen4.5 (default, text+image-to-video), gen4_turbo (image-to-video only)", "gen4.5").option("--no-wait", "Start generation and return task ID without waiting").option("--dry-run", "Preview parameters without executing").addHelpText("after", `
+    generateCommand.command("video").alias("vid").description("Generate video using AI (Kling, Runway, Veo, or Grok)").argument("[prompt]", "Text prompt describing the video (interactive if omitted)").option("-p, --provider <provider>", "Provider: grok (default), kling, runway, veo, fal (Seedance 2.0)", "grok").option("-k, --api-key <key>", "API key (or set XAI_API_KEY / RUNWAY_API_SECRET / KLING_API_KEY / GOOGLE_API_KEY env)").option("-o, --output <path>", "Output file path (downloads video)").option("-i, --image <path>", "Reference image for image-to-video").option("-d, --duration <sec>", "Duration: 5 or 10 seconds", "5").option("-r, --ratio <ratio>", "Aspect ratio: 16:9, 9:16, or 1:1 (auto-detected from image if omitted)").option("-s, --seed <number>", "Random seed for reproducibility (Runway only)").option("-m, --mode <mode>", "Generation mode: std or pro (Kling only)", "std").option("-n, --negative <prompt>", "Negative prompt - what to avoid (Kling/Veo)").option("--resolution <res>", "Video resolution: 720p, 1080p, 4k (Veo only)").option("--last-frame <path>", "Last frame image for frame interpolation (Veo only)").option("--ref-images <paths...>", "Reference images for character consistency (Veo 3.1 only, max 3)").option("--person <mode>", "Person generation: allow_all, allow_adult (Veo only)").option("--veo-model <model>", "Veo model: 3.0, 3.1, 3.1-fast (default: 3.1-fast)", "3.1-fast").option("--runway-model <model>", "Runway model: gen4.5 (default, text+image-to-video), gen4_turbo (image-to-video only)", "gen4.5").option("--no-wait", "Start generation and return task ID without waiting").option("--dry-run", "Preview parameters without executing").addHelpText("after", `
 Examples:
   $ vibe generate video "dancing cat" -o cat.mp4                      # Grok (default)
   $ vibe gen vid "city timelapse" -o city.mp4 -p kling                # Kling
@@ -451211,7 +455477,8 @@ Examples:
           grok: "XAI_API_KEY",
           veo: "GOOGLE_API_KEY",
           kling: "KLING_API_KEY",
-          runway: "RUNWAY_API_SECRET"
+          runway: "RUNWAY_API_SECRET",
+          fal: "FAL_KEY"
         };
         if (videoEnvMap[provider] && !hasApiKey(videoEnvMap[provider]) && !options.apiKey) {
           const resolved = resolveProvider("video");
@@ -451483,6 +455750,37 @@ Examples:
             },
             3e5
           );
+        } else if (provider === "fal") {
+          const fal = new FalProvider();
+          await fal.initialize({ apiKey });
+          let falImage = referenceImage;
+          if (falImage && falImage.startsWith("data:")) {
+            spinner2.text = "Uploading image to ImgBB for fal...";
+            const imgbbKey = await getApiKeyFromConfig("imgbb") || process.env.IMGBB_API_KEY;
+            if (!imgbbKey) {
+              spinner2.fail("ImgBB API key required for fal image-to-video");
+              exitWithError(authError("IMGBB_API_KEY", "ImgBB"));
+            }
+            const base64Data = falImage.split(",")[1];
+            const imageBuffer = Buffer.from(base64Data, "base64");
+            const uploadResult = await uploadToImgbb(imageBuffer, imgbbKey);
+            if (!uploadResult.success || !uploadResult.url) {
+              spinner2.fail("ImgBB upload failed");
+              exitWithError(apiError(`ImgBB upload failed: ${uploadResult.error}`, true));
+            }
+            falImage = uploadResult.url;
+          }
+          spinner2.text = "Generating video with Seedance 2.0 (this may take 1-3 minutes)...";
+          const falModel = options.model === "fast" ? "seedance-2.0-fast" : "seedance-2.0";
+          result = await fal.generateVideo(prompt3, {
+            prompt: prompt3,
+            referenceImage: falImage,
+            duration: options.duration ? parseInt(options.duration) : void 0,
+            aspectRatio: options.ratio,
+            negativePrompt: options.negative,
+            model: falModel
+          });
+          finalResult = result;
         }
         if (!finalResult || finalResult.status !== "completed") {
           spinner2.fail(finalResult?.error || "Generation failed");
@@ -457661,7 +461959,7 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
 }
 
 // ../cli/src/pipeline/executor.ts
-var import_yaml4 = __toESM(require_dist14(), 1);
+var import_yaml4 = __toESM(require_dist16(), 1);
 import { resolve as resolve35 } from "node:path";
 import { readFile as readFile21, writeFile as writeFile22, mkdir as mkdir16 } from "node:fs/promises";
 import { existsSync as existsSync34 } from "node:fs";
@@ -459514,7 +463812,7 @@ init_scene_lint();
 import { resolve as resolve41 } from "node:path";
 
 // ../cli/src/commands/_shared/scene-render.ts
-var import_yaml5 = __toESM(require_dist14(), 1);
+var import_yaml5 = __toESM(require_dist16(), 1);
 init_dist();
 init_chrome();
 init_scene_lint();
@@ -459857,7 +464155,7 @@ async function safeStat(p) {
 init_esm();
 init_source();
 init_ora();
-var import_yaml6 = __toESM(require_dist14(), 1);
+var import_yaml6 = __toESM(require_dist16(), 1);
 init_dist2();
 import { basename as basename18, resolve as resolve40, relative as relative7, dirname as dirname25 } from "node:path";
 import { mkdir as mkdir19, readFile as readFile24, writeFile as writeFile25, access as access5, copyFile as copyFile4 } from "node:fs/promises";
@@ -459923,10 +464221,10 @@ init_scene_lint();
 init_output();
 init_api_key();
 init_audio();
-var VALID_ASPECTS = ["16:9", "9:16", "1:1", "4:5"];
+var VALID_ASPECTS2 = ["16:9", "9:16", "1:1", "4:5"];
 function validateAspect(value) {
-  if (!VALID_ASPECTS.includes(value)) {
-    exitWithError(usageError(`Invalid aspect ratio: ${value}`, `Valid: ${VALID_ASPECTS.join(", ")}`));
+  if (!VALID_ASPECTS2.includes(value)) {
+    exitWithError(usageError(`Invalid aspect ratio: ${value}`, `Valid: ${VALID_ASPECTS2.join(", ")}`));
   }
   return value;
 }