@ghostspeak/plugin-gateway-ghost 0.1.1 → 0.2.1

package/dist/index.js

@@ -1613,6 +1613,3753 @@ var require_base64_js = __commonJS((exports) => {
   }
 });
 
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/middleware.js
+var require_middleware = __commonJS((exports) => {
+  var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, 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 ? resolve(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 = undefined;
+  exports.withMiddleware = withMiddleware;
+  exports.withProxy = withProxy;
+  function withMiddleware(...middlewares) {
+    const isDefined = (middleware) => typeof middleware === "function";
+    return (config) => __awaiter(this, undefined, undefined, function* () {
+      let currentConfig2 = Object.assign({}, config);
+      for (const middleware of middlewares.filter(isDefined)) {
+        currentConfig2 = yield middleware(currentConfig2);
+      }
+      return currentConfig2;
+    });
+  }
+  exports.TARGET_URL_HEADER = "x-fal-target-url";
+  function withProxy(config) {
+    const passthrough = (requestConfig) => Promise.resolve(requestConfig);
+    if (typeof window === "undefined") {
+      return passthrough;
+    }
+    return (requestConfig) => requestConfig.headers && (exports.TARGET_URL_HEADER in requestConfig) ? passthrough(requestConfig) : Promise.resolve(Object.assign(Object.assign({}, requestConfig), { url: config.targetUrl, headers: Object.assign(Object.assign({}, requestConfig.headers || {}), { [exports.TARGET_URL_HEADER]: requestConfig.url }) }));
+  }
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/response.js
+var require_response = __commonJS((exports) => {
+  var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, 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 ? resolve(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 = undefined;
+  exports.defaultResponseHandler = defaultResponseHandler;
+  exports.resultResponseHandler = resultResponseHandler;
+  var REQUEST_ID_HEADER = "x-fal-request-id";
+
+  class ApiError extends Error {
+    constructor({ message, status, body, requestId }) {
+      super(message);
+      this.name = "ApiError";
+      this.status = status;
+      this.body = body;
+      this.requestId = requestId || "";
+    }
+  }
+  exports.ApiError = ApiError;
+
+  class ValidationError 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 __awaiter(this, undefined, undefined, function* () {
+      var _a17;
+      const { status, statusText } = response;
+      const contentType = (_a17 = response.headers.get("Content-Type")) !== null && _a17 !== undefined ? _a17 : "";
+      const requestId = response.headers.get(REQUEST_ID_HEADER) || undefined;
+      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
+          });
+        }
+        throw new ApiError({
+          message: `HTTP ${status}: ${statusText}`,
+          status,
+          requestId
+        });
+      }
+      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 __awaiter(this, undefined, undefined, function* () {
+      const data = yield defaultResponseHandler(response);
+      return {
+        data,
+        requestId: response.headers.get(REQUEST_ID_HEADER) || ""
+      };
+    });
+  }
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/utils.js
+var require_utils3 = __commonJS((exports) => {
+  var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, 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 ? resolve(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.isValidUrl = isValidUrl;
+  exports.throttle = throttle;
+  exports.isReact = isReact;
+  exports.isPlainObject = isPlainObject;
+  exports.sleep = sleep;
+  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("/") || undefined,
+        namespace: parts[0]
+      };
+    }
+    return {
+      owner: parts[0],
+      alias: parts[1],
+      path: parts.slice(2).join("/") || undefined
+    };
+  }
+  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 === undefined) {
+      const stack = new Error().stack;
+      isRunningInReact = !!stack && (stack.includes("node_modules/react-dom/") || stack.includes("node_modules/next/"));
+    }
+    return isRunningInReact;
+  }
+  function isPlainObject(value) {
+    return !!value && Object.getPrototypeOf(value) === Object.prototype;
+  }
+  function sleep(ms) {
+    return __awaiter(this, undefined, undefined, function* () {
+      return new Promise((resolve) => setTimeout(resolve, ms));
+    });
+  }
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/retry.js
+var require_retry = __commonJS((exports) => {
+  var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, 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 ? resolve(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 = undefined;
+  exports.isRetryableError = isRetryableError;
+  exports.calculateBackoffDelay = calculateBackoffDelay;
+  exports.executeWithRetry = executeWithRetry;
+  var response_1 = require_response();
+  var utils_1 = require_utils3();
+  exports.DEFAULT_RETRYABLE_STATUS_CODES = [429, 502, 503, 504];
+  exports.DEFAULT_RETRY_OPTIONS = {
+    maxRetries: 3,
+    baseDelay: 1000,
+    maxDelay: 30000,
+    backoffMultiplier: 2,
+    retryableStatusCodes: exports.DEFAULT_RETRYABLE_STATUS_CODES,
+    enableJitter: true
+  };
+  function isRetryableError(error, retryableStatusCodes) {
+    return error instanceof response_1.ApiError && 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 __awaiter(this, undefined, undefined, 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 delay2 = calculateBackoffDelay(attempt, options.baseDelay, options.maxDelay, options.backoffMultiplier, options.enableJitter);
+          metrics.totalDelay += delay2;
+          if (onRetry) {
+            onRetry(attempt + 1, error, delay2);
+          }
+          yield (0, utils_1.sleep)(delay2);
+        }
+      }
+      throw lastError;
+    });
+  }
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/package.json
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "@fal-ai/client",
+    description: "The fal.ai client for JavaScript and TypeScript",
+    version: "1.8.1",
+    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: ">=22.0.0"
+    },
+    type: "commonjs"
+  };
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/runtime.js
+var require_runtime = __commonJS((exports) => {
+  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_package();
+    memoizedUserAgent = `${packageInfo.name}/${packageInfo.version}`;
+    return memoizedUserAgent;
+  }
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/config.js
+var require_config = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.credentialsFromEnv = undefined;
+  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_runtime();
+  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;
+    }
+    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}` : undefined;
+  };
+  exports.credentialsFromEnv = credentialsFromEnv;
+  var DEFAULT_CONFIG = {
+    credentials: exports.credentialsFromEnv,
+    suppressLocalCredentialsWarning: false,
+    requestMiddleware: (request) => Promise.resolve(request),
+    responseHandler: response_1.defaultResponseHandler,
+    retry: retry_1.DEFAULT_RETRY_OPTIONS
+  };
+  function createConfig(config) {
+    var _a17;
+    let configuration = Object.assign(Object.assign(Object.assign({}, DEFAULT_CONFIG), config), {
+      fetch: (_a17 = config.fetch) !== null && _a17 !== undefined ? _a17 : resolveDefaultFetch(),
+      retry: Object.assign(Object.assign({}, retry_1.DEFAULT_RETRY_OPTIONS), config.retry || {})
+    });
+    if (config.proxyUrl) {
+      configuration = Object.assign(Object.assign({}, configuration), { requestMiddleware: (0, middleware_1.withMiddleware)(configuration.requestMiddleware, (0, middleware_1.withProxy)({ targetUrl: config.proxyUrl })) });
+    }
+    const { credentials: resolveCredentials, suppressLocalCredentialsWarning } = configuration;
+    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 configuration;
+  }
+  function getRestApiUrl() {
+    return "https://rest.alpha.fal.ai";
+  }
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/request.js
+var require_request = __commonJS((exports) => {
+  var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, 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 ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+  var __rest = 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_runtime();
+  var utils_1 = require_utils3();
+  var isCloudflareWorkers = typeof navigator !== "undefined" && (navigator === null || navigator === undefined ? undefined : navigator.userAgent) === "Cloudflare-Workers";
+  function dispatchRequest(params) {
+    return __awaiter(this, undefined, undefined, function* () {
+      var _a17;
+      const { targetUrl, input, config, options = {} } = params;
+      const { credentials: credentialsValue, requestMiddleware, responseHandler, fetch: fetch2 } = config;
+      const retryOptions = Object.assign(Object.assign({}, config.retry), options.retry || {});
+      const executeRequest = () => __awaiter(this, undefined, undefined, function* () {
+        var _a18, _b, _c;
+        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: ((_b = (_a18 = params.method) !== null && _a18 !== undefined ? _a18 : options.method) !== null && _b !== undefined ? _b : "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 !== undefined ? headers : {});
+        const { responseHandler: customResponseHandler, retry: _ } = options, requestInit = __rest(options, ["responseHandler", "retry"]);
+        const response = yield fetch2(url, Object.assign(Object.assign(Object.assign(Object.assign({}, requestInit), { method, headers: Object.assign(Object.assign({}, requestHeaders), (_c = requestInit.headers) !== null && _c !== undefined ? _c : {}) }), !isCloudflareWorkers && { mode: "cors" }), { signal: options.signal, body: method.toLowerCase() !== "get" && input ? JSON.stringify(input) : undefined }));
+        const handleResponse = customResponseHandler !== null && customResponseHandler !== undefined ? 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) || ((_a17 = options.signal) === null || _a17 === undefined ? undefined : _a17.aborted);
+          if (shouldNotRetry) {
+            throw error;
+          }
+          const delay2 = (0, retry_1.calculateBackoffDelay)(attempt, retryOptions.baseDelay, retryOptions.maxDelay, retryOptions.backoffMultiplier, retryOptions.enableJitter);
+          yield (0, utils_1.sleep)(delay2);
+        }
+      }
+      throw lastError;
+    });
+  }
+  function buildUrl(id, options = {}) {
+    var _a17, _b;
+    const method = ((_a17 = options.method) !== null && _a17 !== undefined ? _a17 : "post").toLowerCase();
+    const path = ((_b = options.path) !== null && _b !== undefined ? _b : "").replace(/^\//, "").replace(/\/{2,}/, "/");
+    const input = options.input;
+    const params = Object.assign(Object.assign({}, options.query || {}), method === "get" ? input : {});
+    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}${path}${queryParams}`;
+    }
+    const appId = (0, utils_1.ensureEndpointIdFormat)(id);
+    const subdomain = options.subdomain ? `${options.subdomain}.` : "";
+    const url = `https://${subdomain}fal.run/${appId}/${path}`;
+    return `${url.replace(/\/$/, "")}${queryParams}`;
+  }
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/storage.js
+var require_storage = __commonJS((exports) => {
+  var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, 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 ? resolve(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 = undefined;
+  exports.getExpirationDurationSeconds = getExpirationDurationSeconds;
+  exports.buildObjectLifecycleHeaders = buildObjectLifecycleHeaders;
+  exports.createStorageClient = createStorageClient;
+  var config_1 = require_config();
+  var request_1 = require_request();
+  var utils_1 = require_utils3();
+  exports.OBJECT_LIFECYCYLE_PREFERENCE_HEADER = "x-fal-object-lifecycle-preference";
+  var EXPIRATION_VALUES = {
+    never: 3153600000,
+    immediate: undefined,
+    "1h": 3600,
+    "1d": 86400,
+    "7d": 604800,
+    "30d": 2592000,
+    "1y": 31536000
+  };
+  function getExpirationDurationSeconds(lifecycle) {
+    const { expiresIn } = lifecycle;
+    return typeof expiresIn === "number" ? expiresIn : EXPIRATION_VALUES[expiresIn];
+  }
+  function buildObjectLifecycleHeaders(lifecycle) {
+    if (!lifecycle) {
+      return {};
+    }
+    const expirationDurationSeconds = getExpirationDurationSeconds(lifecycle);
+    if (expirationDurationSeconds === undefined) {
+      return {};
+    }
+    return {
+      [exports.OBJECT_LIFECYCYLE_PREFERENCE_HEADER]: JSON.stringify({
+        expiration_duration_seconds: expirationDurationSeconds
+      })
+    };
+  }
+  function getExtensionFromContentType(contentType) {
+    var _a17;
+    const [, fileType] = contentType.split("/");
+    return (_a17 = fileType.split(/[-;]/)[0]) !== null && _a17 !== undefined ? _a17 : "bin";
+  }
+  function initiateUpload(file, config, contentType, lifecycle) {
+    return __awaiter(this, undefined, undefined, function* () {
+      const filename = file.name || `${Date.now()}.${getExtensionFromContentType(contentType)}`;
+      const headers = {};
+      if (lifecycle) {
+        const lifecycleConfig = {
+          expiration_duration_seconds: getExpirationDurationSeconds(lifecycle),
+          allow_io_storage: lifecycle.expiresIn !== "immediate"
+        };
+        headers["X-Fal-Object-Lifecycle"] = JSON.stringify(lifecycleConfig);
+      }
+      return yield (0, request_1.dispatchRequest)({
+        method: "POST",
+        targetUrl: `${(0, config_1.getRestApiUrl)()}/storage/upload/initiate?storage_type=fal-cdn-v3`,
+        input: {
+          content_type: contentType,
+          file_name: filename
+        },
+        config,
+        headers
+      });
+    });
+  }
+  function initiateMultipartUpload(file, config, contentType, lifecycle) {
+    return __awaiter(this, undefined, undefined, function* () {
+      const filename = file.name || `${Date.now()}.${getExtensionFromContentType(contentType)}`;
+      const headers = {};
+      if (lifecycle) {
+        headers["X-Fal-Object-Lifecycle"] = JSON.stringify(lifecycle);
+      }
+      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,
+        headers
+      });
+    });
+  }
+  function partUploadRetries(uploadUrl_1, chunk_1, config_2) {
+    return __awaiter(this, arguments, undefined, function* (uploadUrl, chunk, config, tries = 3) {
+      if (tries === 0) {
+        throw new Error("Part upload failed, retries exhausted");
+      }
+      const { fetch: fetch2, responseHandler } = config;
+      try {
+        const response = yield fetch2(uploadUrl, {
+          method: "PUT",
+          body: chunk
+        });
+        return yield responseHandler(response);
+      } catch (error) {
+        return yield partUploadRetries(uploadUrl, chunk, config, tries - 1);
+      }
+    });
+  }
+  function multipartUpload(file, config, lifecycle) {
+    return __awaiter(this, undefined, undefined, function* () {
+      const { fetch: fetch2, responseHandler } = config;
+      const contentType = file.type || "application/octet-stream";
+      const { upload_url: uploadUrl, file_url: url } = yield initiateMultipartUpload(file, config, 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, config));
+      }
+      const completeUrl = `${parsedUrl.origin}${parsedUrl.pathname}/complete${parsedUrl.search}`;
+      const response = yield fetch2(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 }) {
+    const ref = {
+      upload: (file, options) => __awaiter(this, undefined, undefined, function* () {
+        const lifecycle = options === null || options === undefined ? undefined : options.lifecycle;
+        if (file.size > 90 * 1024 * 1024) {
+          return yield multipartUpload(file, config, lifecycle);
+        }
+        const contentType = file.type || "application/octet-stream";
+        const { fetch: fetch2, responseHandler } = config;
+        const { upload_url: uploadUrl, file_url: url } = yield initiateUpload(file, config, contentType, lifecycle);
+        const response = yield fetch2(uploadUrl, {
+          method: "PUT",
+          body: file,
+          headers: {
+            "Content-Type": file.type || "application/octet-stream"
+          }
+        });
+        yield responseHandler(response);
+        return url;
+      }),
+      transformInput: (input) => __awaiter(this, undefined, undefined, function* () {
+        if (Array.isArray(input)) {
+          return Promise.all(input.map((item) => ref.transformInput(item)));
+        } else if (input instanceof Blob) {
+          return yield ref.upload(input);
+        } else if ((0, utils_1.isPlainObject)(input)) {
+          const inputObject = input;
+          const promises = Object.entries(inputObject).map((_a17) => __awaiter(this, [_a17], undefined, function* ([key, value]) {
+            return [key, yield ref.transformInput(value)];
+          }));
+          const results = yield Promise.all(promises);
+          return Object.fromEntries(results);
+        }
+        return input;
+      })
+    };
+    return ref;
+  }
+});
+
+// ../../node_modules/.bun/eventsource-parser@1.1.2/node_modules/eventsource-parser/dist/index.cjs
+var require_dist = __commonJS((exports) => {
+  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 = undefined;
+      eventName = undefined;
+      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] === `
+`) {
+            ++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 === `
+`) {
+            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 || undefined,
+            data: data.slice(0, -1)
+          });
+          data = "";
+          eventId = undefined;
+        }
+        eventName = undefined;
+        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, `
+`) : `
+`;
+      } else if (field === "event") {
+        eventName = value;
+      } else if (field === "id" && !value.includes("\x00")) {
+        eventId = value;
+      } else if (field === "retry") {
+        const retry = parseInt(value, 10);
+        if (!Number.isNaN(retry)) {
+          onParse({
+            type: "reconnect-interval",
+            value: retry
+          });
+        }
+      }
+    }
+  }
+  var BOM = [239, 187, 191];
+  function hasBom(buffer) {
+    return BOM.every((charCode, index) => buffer.charCodeAt(index) === charCode);
+  }
+  exports.createParser = createParser;
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/auth.js
+var require_auth = __commonJS((exports) => {
+  var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, 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 ? resolve(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 = undefined;
+  exports.getTemporaryAuthToken = getTemporaryAuthToken;
+  var config_1 = require_config();
+  var request_1 = require_request();
+  var utils_1 = require_utils3();
+  exports.TOKEN_EXPIRATION_SECONDS = 120;
+  function getTemporaryAuthToken(app, config) {
+    return __awaiter(this, undefined, undefined, function* () {
+      const appId = (0, utils_1.parseEndpointId)(app);
+      const token = yield (0, request_1.dispatchRequest)({
+        method: "POST",
+        targetUrl: `${(0, config_1.getRestApiUrl)()}/tokens/`,
+        config,
+        input: {
+          allowed_apps: [appId.alias],
+          token_expiration: exports.TOKEN_EXPIRATION_SECONDS
+        }
+      });
+      if (typeof token !== "string" && token["detail"]) {
+        return token["detail"];
+      }
+      return token;
+    });
+  }
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/streaming.js
+var require_streaming = __commonJS((exports) => {
+  var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, 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 ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+  var __await = exports && exports.__await || function(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+  };
+  var __asyncGenerator = 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 __await ? 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 = undefined;
+  exports.createStreamingClient = createStreamingClient;
+  var eventsource_parser_1 = require_dist();
+  var auth_1 = require_auth();
+  var request_1 = require_request();
+  var response_1 = require_response();
+  var CONTENT_TYPE_EVENT_STREAM = "text/event-stream";
+  var EVENT_STREAM_TIMEOUT = 15 * 1000;
+
+  class FalStream {
+    constructor(endpointId, config, options) {
+      var _a17;
+      this.listeners = new Map;
+      this.buffer = [];
+      this.currentData = undefined;
+      this.lastEventTimestamp = 0;
+      this.streamClosed = false;
+      this._requestId = null;
+      this.abortController = new AbortController;
+      this.start = () => __awaiter(this, undefined, undefined, function* () {
+        var _a18, _b;
+        const { endpointId: endpointId2, options: options2 } = this;
+        const { input, method = "post", connectionMode = "server" } = options2;
+        try {
+          if (connectionMode === "client") {
+            const token = yield (0, auth_1.getTemporaryAuthToken)(endpointId2, this.config);
+            const { fetch: fetch2 } = this.config;
+            const parsedUrl = new URL(this.url);
+            parsedUrl.searchParams.set("fal_jwt_token", token);
+            const response = yield fetch2(parsedUrl.toString(), {
+              method: method.toUpperCase(),
+              headers: {
+                accept: (_a18 = options2.accept) !== null && _a18 !== undefined ? _a18 : CONTENT_TYPE_EVENT_STREAM,
+                "content-type": "application/json"
+              },
+              body: input && method !== "get" ? JSON.stringify(input) : undefined,
+              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,
+            config: this.config,
+            options: {
+              headers: {
+                accept: (_b = options2.accept) !== null && _b !== undefined ? _b : CONTENT_TYPE_EVENT_STREAM
+              },
+              responseHandler: (response) => __awaiter(this, undefined, undefined, 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) => __awaiter(this, undefined, undefined, function* () {
+        var _a18, _b;
+        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: undefined,
+            requestId: this._requestId || undefined
+          }));
+          return;
+        }
+        const isEventStream = ((_a18 = response.headers.get("content-type")) !== null && _a18 !== undefined ? _a18 : "").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 decoder = new TextDecoder("utf-8");
+        const reader = response.body.getReader();
+        const parser = (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 timeout = (_b = this.options.timeout) !== null && _b !== undefined ? _b : EVENT_STREAM_TIMEOUT;
+        const readPartialResponse = () => __awaiter(this, undefined, undefined, function* () {
+          const { value, done } = yield reader.read();
+          this.lastEventTimestamp = Date.now();
+          parser.feed(decoder.decode(value));
+          if (Date.now() - this.lastEventTimestamp > timeout) {
+            this.emit("error", new response_1.ApiError({
+              message: `Event stream timed out after ${(timeout / 1000).toFixed(0)} seconds with no messages.`,
+              status: 408,
+              requestId: this._requestId || undefined
+            }));
+          }
+          if (!done) {
+            readPartialResponse().catch(this.handleError);
+          } else {
+            this.emit("done", this.currentData);
+          }
+        });
+        readPartialResponse().catch(this.handleError);
+        return;
+      });
+      this.handleError = (error) => {
+        var _a18;
+        if (error.name === "AbortError" || this.signal.aborted) {
+          return;
+        }
+        const apiError = error instanceof response_1.ApiError ? error : new response_1.ApiError({
+          message: (_a18 = error.message) !== null && _a18 !== undefined ? _a18 : "An unknown error occurred",
+          status: 500,
+          requestId: this._requestId || undefined
+        });
+        this.emit("error", apiError);
+        return;
+      };
+      this.on = (type, listener) => {
+        var _a18;
+        if (!this.listeners.has(type)) {
+          this.listeners.set(type, []);
+        }
+        (_a18 = this.listeners.get(type)) === null || _a18 === undefined || _a18.push(listener);
+      };
+      this.emit = (type, event) => {
+        const listeners = this.listeners.get(type) || [];
+        for (const listener of listeners) {
+          listener(event);
+        }
+      };
+      this.done = () => __awaiter(this, undefined, undefined, function* () {
+        return this.donePromise;
+      });
+      this.abort = (reason) => {
+        if (!this.streamClosed) {
+          this.abortController.abort(reason);
+        }
+      };
+      this.endpointId = endpointId;
+      this.config = config;
+      this.url = (_a17 = options.url) !== null && _a17 !== undefined ? _a17 : (0, request_1.buildUrl)(endpointId, {
+        path: "/stream",
+        query: options.queryParams
+      });
+      this.options = options;
+      this.donePromise = new Promise((resolve, reject) => {
+        if (this.streamClosed) {
+          reject(new response_1.ApiError({
+            message: "Streaming connection is already closed.",
+            status: 400,
+            body: undefined,
+            requestId: this._requestId || undefined
+          }));
+        }
+        this.signal.addEventListener("abort", () => {
+          var _a18;
+          resolve((_a18 = this.currentData) !== null && _a18 !== undefined ? _a18 : {});
+        });
+        this.on("done", (data) => {
+          this.streamClosed = true;
+          resolve(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 __asyncGenerator(this, arguments, function* _a() {
+        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 __await(data);
+          }
+          yield __await(new Promise((resolve) => setTimeout(resolve, 16)));
+        }
+      });
+    }
+    get signal() {
+      return this.abortController.signal;
+    }
+    get requestId() {
+      return this._requestId;
+    }
+  }
+  exports.FalStream = FalStream;
+  function createStreamingClient({ config, storage }) {
+    return {
+      stream(endpointId, options) {
+        return __awaiter(this, undefined, undefined, function* () {
+          const input = options.input ? yield storage.transformInput(options.input) : undefined;
+          return new FalStream(endpointId, config, Object.assign(Object.assign({}, options), { input }));
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/queue.js
+var require_queue = __commonJS((exports) => {
+  var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, 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 ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+  var __rest = 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 = undefined;
+  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_utils3();
+  var DEFAULT_POLL_INTERVAL = 500;
+  var QUEUE_PRIORITY_HEADER = "x-fal-queue-priority";
+  var RUNNER_HINT_HEADER = "x-fal-runner-hint";
+  var QUEUE_RETRY_CONFIG = {
+    maxRetries: 3,
+    baseDelay: 1000,
+    maxDelay: 60000,
+    retryableStatusCodes: retry_1.DEFAULT_RETRYABLE_STATUS_CODES
+  };
+  var QUEUE_STATUS_RETRY_CONFIG = {
+    maxRetries: 5,
+    baseDelay: 1000,
+    maxDelay: 30000,
+    retryableStatusCodes: [...retry_1.DEFAULT_RETRYABLE_STATUS_CODES, 500]
+  };
+  var createQueueClient = ({ config, storage }) => {
+    const ref = {
+      submit(endpointId, options) {
+        return __awaiter(this, undefined, undefined, function* () {
+          const { webhookUrl, priority, hint, headers, storageSettings } = options, runOptions = __rest(options, ["webhookUrl", "priority", "hint", "headers", "storageSettings"]);
+          const input = options.input ? yield storage.transformInput(options.input) : undefined;
+          const extraHeaders = Object.fromEntries(Object.entries(headers !== null && headers !== undefined ? headers : {}).map(([key, value]) => [
+            key.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 } : undefined })),
+            headers: Object.assign(Object.assign(Object.assign(Object.assign({}, extraHeaders), (0, storage_1.buildObjectLifecycleHeaders)(storageSettings)), { [QUEUE_PRIORITY_HEADER]: priority !== null && priority !== undefined ? priority : "normal" }), hint && { [RUNNER_HINT_HEADER]: hint }),
+            input,
+            config,
+            options: {
+              signal: options.abortSignal,
+              retry: QUEUE_RETRY_CONFIG
+            }
+          });
+        });
+      },
+      status(endpointId_1, _a17) {
+        return __awaiter(this, arguments, undefined, 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,
+            options: {
+              signal: abortSignal,
+              retry: QUEUE_STATUS_RETRY_CONFIG
+            }
+          });
+        });
+      },
+      streamStatus(endpointId_1, _a17) {
+        return __awaiter(this, arguments, undefined, 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, config, {
+            url,
+            method: "get",
+            connectionMode,
+            queryParams
+          });
+        });
+      },
+      subscribeToStatus(endpointId, options) {
+        return __awaiter(this, undefined, undefined, function* () {
+          const requestId = options.requestId;
+          const timeout = options.timeout;
+          let timeoutId = undefined;
+          const handleCancelError = () => {};
+          if (options.mode === "streaming") {
+            const status = yield ref.streamStatus(endpointId, {
+              requestId,
+              logs: options.logs,
+              connectionMode: "connectionMode" in options ? options.connectionMode : undefined
+            });
+            const logs = [];
+            if (timeout) {
+              timeoutId = setTimeout(() => {
+                status.abort();
+                ref.cancel(endpointId, { requestId }).catch(handleCancelError);
+                throw new Error(`Client timed out waiting for the request to complete after ${timeout}ms`);
+              }, timeout);
+            }
+            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((resolve, reject) => {
+            var _a17;
+            let pollingTimeoutId;
+            const pollInterval = "pollInterval" in options && typeof options.pollInterval === "number" ? (_a17 = options.pollInterval) !== null && _a17 !== undefined ? _a17 : DEFAULT_POLL_INTERVAL : DEFAULT_POLL_INTERVAL;
+            const clearScheduledTasks = () => {
+              if (timeoutId) {
+                clearTimeout(timeoutId);
+              }
+              if (pollingTimeoutId) {
+                clearTimeout(pollingTimeoutId);
+              }
+            };
+            if (timeout) {
+              timeoutId = setTimeout(() => {
+                clearScheduledTasks();
+                ref.cancel(endpointId, { requestId }).catch(handleCancelError);
+                reject(new Error(`Client timed out waiting for the request to complete after ${timeout}ms`));
+              }, timeout);
+            }
+            const poll = () => __awaiter(this, undefined, undefined, function* () {
+              var _a18;
+              try {
+                const requestStatus = yield ref.status(endpointId, {
+                  requestId,
+                  logs: (_a18 = options.logs) !== null && _a18 !== undefined ? _a18 : false,
+                  abortSignal: options.abortSignal
+                });
+                if (options.onQueueUpdate) {
+                  options.onQueueUpdate(requestStatus);
+                }
+                if (requestStatus.status === "COMPLETED") {
+                  clearScheduledTasks();
+                  resolve(requestStatus);
+                  return;
+                }
+                pollingTimeoutId = setTimeout(poll, pollInterval);
+              } catch (error) {
+                clearScheduledTasks();
+                reject(error);
+              }
+            });
+            poll().catch(reject);
+          });
+        });
+      },
+      result(endpointId_1, _a17) {
+        return __awaiter(this, arguments, undefined, 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({}, config), { responseHandler: response_1.resultResponseHandler }),
+            options: {
+              signal: abortSignal,
+              retry: QUEUE_RETRY_CONFIG
+            }
+          });
+        });
+      },
+      cancel(endpointId_1, _a17) {
+        return __awaiter(this, arguments, undefined, 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,
+            options: {
+              signal: abortSignal
+            }
+          });
+        });
+      }
+    };
+    return ref;
+  };
+  exports.createQueueClient = createQueueClient;
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/utils/utf8.cjs
+var require_utf8 = __commonJS((exports) => {
+  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, output, outputOffset) {
+    const strLength = str.length;
+    let offset = outputOffset;
+    let pos = 0;
+    while (pos < strLength) {
+      let value = str.charCodeAt(pos++);
+      if ((value & 4294967168) === 0) {
+        output[offset++] = value;
+        continue;
+      } else if ((value & 4294965248) === 0) {
+        output[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) {
+          output[offset++] = value >> 12 & 15 | 224;
+          output[offset++] = value >> 6 & 63 | 128;
+        } else {
+          output[offset++] = value >> 18 & 7 | 240;
+          output[offset++] = value >> 12 & 63 | 128;
+          output[offset++] = value >> 6 & 63 | 128;
+        }
+      }
+      output[offset++] = value & 63 | 128;
+    }
+  }
+  var sharedTextEncoder = new TextEncoder;
+  var TEXT_ENCODER_THRESHOLD = 50;
+  function utf8EncodeTE(str, output, outputOffset) {
+    sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+  }
+  function utf8Encode(str, output, outputOffset) {
+    if (str.length > TEXT_ENCODER_THRESHOLD) {
+      utf8EncodeTE(str, output, outputOffset);
+    } else {
+      utf8EncodeJs(str, output, outputOffset);
+    }
+  }
+  var CHUNK_SIZE = 4096;
+  function utf8DecodeJs(bytes, inputOffset, byteLength) {
+    let offset = inputOffset;
+    const end = offset + byteLength;
+    const units = [];
+    let result = "";
+    while (offset < end) {
+      const byte1 = bytes[offset++];
+      if ((byte1 & 128) === 0) {
+        units.push(byte1);
+      } else if ((byte1 & 224) === 192) {
+        const byte2 = bytes[offset++] & 63;
+        units.push((byte1 & 31) << 6 | byte2);
+      } else if ((byte1 & 240) === 224) {
+        const byte2 = bytes[offset++] & 63;
+        const byte3 = bytes[offset++] & 63;
+        units.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;
+          units.push(unit >>> 10 & 1023 | 55296);
+          unit = 56320 | unit & 1023;
+        }
+        units.push(unit);
+      } else {
+        units.push(byte1);
+      }
+      if (units.length >= CHUNK_SIZE) {
+        result += String.fromCharCode(...units);
+        units.length = 0;
+      }
+    }
+    if (units.length > 0) {
+      result += String.fromCharCode(...units);
+    }
+    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/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/ExtData.cjs
+var require_ExtData = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ExtData = undefined;
+
+  class ExtData {
+    constructor(type, data) {
+      this.type = type;
+      this.data = data;
+    }
+  }
+  exports.ExtData = ExtData;
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/DecodeError.cjs
+var require_DecodeError = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.DecodeError = undefined;
+
+  class DecodeError extends Error {
+    constructor(message) {
+      super(message);
+      const proto = Object.create(DecodeError.prototype);
+      Object.setPrototypeOf(this, proto);
+      Object.defineProperty(this, "name", {
+        configurable: true,
+        enumerable: false,
+        value: DecodeError.name
+      });
+    }
+  }
+  exports.DecodeError = DecodeError;
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/utils/int.cjs
+var require_int = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.UINT32_MAX = undefined;
+  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/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/timestamp.cjs
+var require_timestamp = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.timestampExtension = exports.EXT_TIMESTAMP = undefined;
+  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_int();
+  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(date2) {
+    const msec = date2.getTime();
+    const sec = Math.floor(msec / 1000);
+    const nsec = (msec - sec * 1000) * 1e6;
+    const nsecInSec = Math.floor(nsec / 1e9);
+    return {
+      sec: sec + nsecInSec,
+      nsec: nsec - nsecInSec * 1e9
+    };
+  }
+  function encodeTimestampExtension(object3) {
+    if (object3 instanceof Date) {
+      const timeSpec = encodeDateToTimeSpec(object3);
+      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 * 1000 + timeSpec.nsec / 1e6);
+  }
+  exports.timestampExtension = {
+    type: exports.EXT_TIMESTAMP,
+    encode: encodeTimestampExtension,
+    decode: decodeTimestampExtension
+  };
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/ExtensionCodec.cjs
+var require_ExtensionCodec = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ExtensionCodec = undefined;
+  var ExtData_ts_1 = require_ExtData();
+  var timestamp_ts_1 = require_timestamp();
+
+  class ExtensionCodec {
+    constructor() {
+      this.builtInEncoders = [];
+      this.builtInDecoders = [];
+      this.encoders = [];
+      this.decoders = [];
+      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(object3, context) {
+      for (let i = 0;i < this.builtInEncoders.length; i++) {
+        const encodeExt = this.builtInEncoders[i];
+        if (encodeExt != null) {
+          const data = encodeExt(object3, context);
+          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(object3, context);
+          if (data != null) {
+            const type = i;
+            return new ExtData_ts_1.ExtData(type, data);
+          }
+        }
+      }
+      if (object3 instanceof ExtData_ts_1.ExtData) {
+        return object3;
+      }
+      return null;
+    }
+    decode(data, type, context) {
+      const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+      if (decodeExt) {
+        return decodeExt(data, type, context);
+      } else {
+        return new ExtData_ts_1.ExtData(type, data);
+      }
+    }
+  }
+  exports.ExtensionCodec = ExtensionCodec;
+  ExtensionCodec.defaultCodec = new ExtensionCodec;
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/utils/typedArrays.cjs
+var require_typedArrays = __commonJS((exports) => {
+  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/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/Encoder.cjs
+var require_Encoder = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Encoder = exports.DEFAULT_INITIAL_BUFFER_SIZE = exports.DEFAULT_MAX_DEPTH = undefined;
+  var utf8_ts_1 = require_utf8();
+  var ExtensionCodec_ts_1 = require_ExtensionCodec();
+  var int_ts_1 = require_int();
+  var typedArrays_ts_1 = require_typedArrays();
+  exports.DEFAULT_MAX_DEPTH = 100;
+  exports.DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+
+  class Encoder {
+    constructor(options) {
+      this.entered = false;
+      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;
+    }
+    encodeSharedRef(object3) {
+      if (this.entered) {
+        const instance = this.clone();
+        return instance.encodeSharedRef(object3);
+      }
+      try {
+        this.entered = true;
+        this.reinitializeState();
+        this.doEncode(object3, 1);
+        return this.bytes.subarray(0, this.pos);
+      } finally {
+        this.entered = false;
+      }
+    }
+    encode(object3) {
+      if (this.entered) {
+        const instance = this.clone();
+        return instance.encode(object3);
+      }
+      try {
+        this.entered = true;
+        this.reinitializeState();
+        this.doEncode(object3, 1);
+        return this.bytes.slice(0, this.pos);
+      } finally {
+        this.entered = false;
+      }
+    }
+    doEncode(object3, depth) {
+      if (depth > this.maxDepth) {
+        throw new Error(`Too deep objects in depth ${depth}`);
+      }
+      if (object3 == null) {
+        this.encodeNil();
+      } else if (typeof object3 === "boolean") {
+        this.encodeBoolean(object3);
+      } else if (typeof object3 === "number") {
+        if (!this.forceIntegerToFloat) {
+          this.encodeNumber(object3);
+        } else {
+          this.encodeNumberAsFloat(object3);
+        }
+      } else if (typeof object3 === "string") {
+        this.encodeString(object3);
+      } else if (this.useBigInt64 && typeof object3 === "bigint") {
+        this.encodeBigInt64(object3);
+      } else {
+        this.encodeObject(object3, 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(object3) {
+      if (object3 === false) {
+        this.writeU8(194);
+      } else {
+        this.writeU8(195);
+      }
+    }
+    encodeNumber(object3) {
+      if (!this.forceIntegerToFloat && Number.isSafeInteger(object3)) {
+        if (object3 >= 0) {
+          if (object3 < 128) {
+            this.writeU8(object3);
+          } else if (object3 < 256) {
+            this.writeU8(204);
+            this.writeU8(object3);
+          } else if (object3 < 65536) {
+            this.writeU8(205);
+            this.writeU16(object3);
+          } else if (object3 < 4294967296) {
+            this.writeU8(206);
+            this.writeU32(object3);
+          } else if (!this.useBigInt64) {
+            this.writeU8(207);
+            this.writeU64(object3);
+          } else {
+            this.encodeNumberAsFloat(object3);
+          }
+        } else {
+          if (object3 >= -32) {
+            this.writeU8(224 | object3 + 32);
+          } else if (object3 >= -128) {
+            this.writeU8(208);
+            this.writeI8(object3);
+          } else if (object3 >= -32768) {
+            this.writeU8(209);
+            this.writeI16(object3);
+          } else if (object3 >= -2147483648) {
+            this.writeU8(210);
+            this.writeI32(object3);
+          } else if (!this.useBigInt64) {
+            this.writeU8(211);
+            this.writeI64(object3);
+          } else {
+            this.encodeNumberAsFloat(object3);
+          }
+        }
+      } else {
+        this.encodeNumberAsFloat(object3);
+      }
+    }
+    encodeNumberAsFloat(object3) {
+      if (this.forceFloat32) {
+        this.writeU8(202);
+        this.writeF32(object3);
+      } else {
+        this.writeU8(203);
+        this.writeF64(object3);
+      }
+    }
+    encodeBigInt64(object3) {
+      if (object3 >= BigInt(0)) {
+        this.writeU8(207);
+        this.writeBigUint64(object3);
+      } else {
+        this.writeU8(211);
+        this.writeBigInt64(object3);
+      }
+    }
+    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(object3) {
+      const maxHeaderSize = 1 + 4;
+      const byteLength = (0, utf8_ts_1.utf8Count)(object3);
+      this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+      this.writeStringHeader(byteLength);
+      (0, utf8_ts_1.utf8Encode)(object3, this.bytes, this.pos);
+      this.pos += byteLength;
+    }
+    encodeObject(object3, depth) {
+      const ext = this.extensionCodec.tryToEncode(object3, this.context);
+      if (ext != null) {
+        this.encodeExtension(ext);
+      } else if (Array.isArray(object3)) {
+        this.encodeArray(object3, depth);
+      } else if (ArrayBuffer.isView(object3)) {
+        this.encodeBinary(object3);
+      } else if (typeof object3 === "object") {
+        this.encodeMap(object3, depth);
+      } else {
+        throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object3)}`);
+      }
+    }
+    encodeBinary(object3) {
+      const size = object3.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)(object3);
+      this.writeU8a(bytes);
+    }
+    encodeArray(object3, depth) {
+      const size = object3.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 object3) {
+        this.doEncode(item, depth + 1);
+      }
+    }
+    countWithoutUndefined(object3, keys) {
+      let count = 0;
+      for (const key of keys) {
+        if (object3[key] !== undefined) {
+          count++;
+        }
+      }
+      return count;
+    }
+    encodeMap(object3, depth) {
+      const keys = Object.keys(object3);
+      if (this.sortKeys) {
+        keys.sort();
+      }
+      const size = this.ignoreUndefined ? this.countWithoutUndefined(object3, keys) : keys.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 key of keys) {
+        const value = object3[key];
+        if (!(this.ignoreUndefined && value === undefined)) {
+          this.encodeString(key);
+          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/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/encode.cjs
+var require_encode = __commonJS((exports) => {
+  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/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/utils/prettyByte.cjs
+var require_prettyByte = __commonJS((exports) => {
+  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/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/CachedKeyDecoder.cjs
+var require_CachedKeyDecoder = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.CachedKeyDecoder = undefined;
+  var utf8_ts_1 = require_utf8();
+  var DEFAULT_MAX_KEY_LENGTH = 16;
+  var DEFAULT_MAX_LENGTH_PER_KEY = 16;
+
+  class CachedKeyDecoder {
+    constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+      this.hit = 0;
+      this.miss = 0;
+      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 record2 of records) {
+          const recordBytes = record2.bytes;
+          for (let j = 0;j < byteLength; j++) {
+            if (recordBytes[j] !== bytes[inputOffset + j]) {
+              continue FIND_CHUNK;
+            }
+          }
+          return record2.str;
+        }
+      return null;
+    }
+    store(bytes, value) {
+      const records = this.caches[bytes.length - 1];
+      const record2 = { bytes, str: value };
+      if (records.length >= this.maxLengthPerKey) {
+        records[Math.random() * records.length | 0] = record2;
+      } else {
+        records.push(record2);
+      }
+    }
+    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/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/Decoder.cjs
+var require_Decoder = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Decoder = undefined;
+  var prettyByte_ts_1 = require_prettyByte();
+  var ExtensionCodec_ts_1 = require_ExtensionCodec();
+  var int_ts_1 = require_int();
+  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 = (key) => {
+    if (typeof key === "string" || typeof key === "number") {
+      return key;
+    }
+    throw new DecodeError_ts_1.DecodeError("The type of key must be string or number but " + typeof key);
+  };
+
+  class StackPool {
+    constructor() {
+      this.stack = [];
+      this.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: undefined,
+          size: 0,
+          array: undefined,
+          position: 0,
+          readCount: 0,
+          map: undefined,
+          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 = undefined;
+        partialState.position = 0;
+        partialState.type = undefined;
+      }
+      if (state.type === STATE_MAP_KEY || state.type === STATE_MAP_VALUE) {
+        const partialState = state;
+        partialState.size = 0;
+        partialState.map = undefined;
+        partialState.readCount = 0;
+        partialState.type = undefined;
+      }
+      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;
+
+  class Decoder {
+    constructor(options) {
+      this.totalPos = 0;
+      this.pos = 0;
+      this.view = EMPTY_VIEW;
+      this.bytes = EMPTY_BYTES;
+      this.headByte = HEAD_BYTE_REQUIRED;
+      this.stack = new StackPool;
+      this.entered = false;
+      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 !== undefined ? 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}]`);
+    }
+    decode(buffer) {
+      if (this.entered) {
+        const instance = this.clone();
+        return instance.decode(buffer);
+      }
+      try {
+        this.entered = true;
+        this.reinitializeState();
+        this.setBuffer(buffer);
+        const object3 = this.doDecodeSync();
+        if (this.hasRemaining(1)) {
+          throw this.createExtraByteError(this.pos);
+        }
+        return object3;
+      } 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 object3;
+        for await (const buffer of stream) {
+          if (decoded) {
+            this.entered = false;
+            throw this.createExtraByteError(this.totalPos);
+          }
+          this.appendBuffer(buffer);
+          try {
+            object3 = 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 object3;
+        }
+        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, isArray) {
+      if (this.entered) {
+        const instance = this.clone();
+        yield* instance.decodeMultiAsync(stream, isArray);
+        return;
+      }
+      try {
+        this.entered = true;
+        let isArrayHeaderRequired = isArray;
+        let arrayItemsLeft = -1;
+        for await (const buffer of stream) {
+          if (isArray && 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 object3;
+          if (headByte >= 224) {
+            object3 = headByte - 256;
+          } else if (headByte < 192) {
+            if (headByte < 128) {
+              object3 = headByte;
+            } else if (headByte < 144) {
+              const size = headByte - 128;
+              if (size !== 0) {
+                this.pushMapState(size);
+                this.complete();
+                continue DECODE;
+              } else {
+                object3 = {};
+              }
+            } else if (headByte < 160) {
+              const size = headByte - 144;
+              if (size !== 0) {
+                this.pushArrayState(size);
+                this.complete();
+                continue DECODE;
+              } else {
+                object3 = [];
+              }
+            } else {
+              const byteLength = headByte - 160;
+              object3 = this.decodeString(byteLength, 0);
+            }
+          } else if (headByte === 192) {
+            object3 = null;
+          } else if (headByte === 194) {
+            object3 = false;
+          } else if (headByte === 195) {
+            object3 = true;
+          } else if (headByte === 202) {
+            object3 = this.readF32();
+          } else if (headByte === 203) {
+            object3 = this.readF64();
+          } else if (headByte === 204) {
+            object3 = this.readU8();
+          } else if (headByte === 205) {
+            object3 = this.readU16();
+          } else if (headByte === 206) {
+            object3 = this.readU32();
+          } else if (headByte === 207) {
+            if (this.useBigInt64) {
+              object3 = this.readU64AsBigInt();
+            } else {
+              object3 = this.readU64();
+            }
+          } else if (headByte === 208) {
+            object3 = this.readI8();
+          } else if (headByte === 209) {
+            object3 = this.readI16();
+          } else if (headByte === 210) {
+            object3 = this.readI32();
+          } else if (headByte === 211) {
+            if (this.useBigInt64) {
+              object3 = this.readI64AsBigInt();
+            } else {
+              object3 = this.readI64();
+            }
+          } else if (headByte === 217) {
+            const byteLength = this.lookU8();
+            object3 = this.decodeString(byteLength, 1);
+          } else if (headByte === 218) {
+            const byteLength = this.lookU16();
+            object3 = this.decodeString(byteLength, 2);
+          } else if (headByte === 219) {
+            const byteLength = this.lookU32();
+            object3 = this.decodeString(byteLength, 4);
+          } else if (headByte === 220) {
+            const size = this.readU16();
+            if (size !== 0) {
+              this.pushArrayState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object3 = [];
+            }
+          } else if (headByte === 221) {
+            const size = this.readU32();
+            if (size !== 0) {
+              this.pushArrayState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object3 = [];
+            }
+          } else if (headByte === 222) {
+            const size = this.readU16();
+            if (size !== 0) {
+              this.pushMapState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object3 = {};
+            }
+          } else if (headByte === 223) {
+            const size = this.readU32();
+            if (size !== 0) {
+              this.pushMapState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object3 = {};
+            }
+          } else if (headByte === 196) {
+            const size = this.lookU8();
+            object3 = this.decodeBinary(size, 1);
+          } else if (headByte === 197) {
+            const size = this.lookU16();
+            object3 = this.decodeBinary(size, 2);
+          } else if (headByte === 198) {
+            const size = this.lookU32();
+            object3 = this.decodeBinary(size, 4);
+          } else if (headByte === 212) {
+            object3 = this.decodeExtension(1, 0);
+          } else if (headByte === 213) {
+            object3 = this.decodeExtension(2, 0);
+          } else if (headByte === 214) {
+            object3 = this.decodeExtension(4, 0);
+          } else if (headByte === 215) {
+            object3 = this.decodeExtension(8, 0);
+          } else if (headByte === 216) {
+            object3 = this.decodeExtension(16, 0);
+          } else if (headByte === 199) {
+            const size = this.lookU8();
+            object3 = this.decodeExtension(size, 1);
+          } else if (headByte === 200) {
+            const size = this.lookU16();
+            object3 = this.decodeExtension(size, 2);
+          } else if (headByte === 201) {
+            const size = this.lookU32();
+            object3 = 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] = object3;
+              state.position++;
+              if (state.position === state.size) {
+                object3 = state.array;
+                stack.release(state);
+              } else {
+                continue DECODE;
+              }
+            } else if (state.type === STATE_MAP_KEY) {
+              if (object3 === "__proto__") {
+                throw new DecodeError_ts_1.DecodeError("The key __proto__ is not allowed");
+              }
+              state.key = this.mapKeyConverter(object3);
+              state.type = STATE_MAP_VALUE;
+              continue DECODE;
+            } else {
+              state.map[state.key] = object3;
+              state.readCount++;
+              if (state.readCount === state.size) {
+                object3 = state.map;
+                stack.release(state);
+              } else {
+                state.key = null;
+                state.type = STATE_MAP_KEY;
+                continue DECODE;
+              }
+            }
+          }
+          return object3;
+        }
+    }
+    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);
+    }
+    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 object3;
+      if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {
+        object3 = this.keyDecoder.decode(this.bytes, offset, byteLength);
+      } else {
+        object3 = (0, utf8_ts_1.utf8Decode)(this.bytes, offset, byteLength);
+      }
+      this.pos += headerOffset + byteLength;
+      return object3;
+    }
+    stateIsMapKey() {
+      if (this.stack.length > 0) {
+        const state = this.stack.top();
+        return state.type === STATE_MAP_KEY;
+      }
+      return false;
+    }
+    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 object3 = this.bytes.subarray(offset, offset + byteLength);
+      this.pos += headOffset + byteLength;
+      return object3;
+    }
+    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);
+      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/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/decode.cjs
+var require_decode = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.decode = decode;
+  exports.decodeMulti = decodeMulti;
+  var Decoder_ts_1 = require_Decoder();
+  function decode(buffer, options) {
+    const decoder = new Decoder_ts_1.Decoder(options);
+    return decoder.decode(buffer);
+  }
+  function decodeMulti(buffer, options) {
+    const decoder = new Decoder_ts_1.Decoder(options);
+    return decoder.decodeMulti(buffer);
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/utils/stream.cjs
+var require_stream = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isAsyncIterable = isAsyncIterable;
+  exports.asyncIterableFromStream = asyncIterableFromStream;
+  exports.ensureAsyncIterable = ensureAsyncIterable;
+  function isAsyncIterable(object3) {
+    return object3[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 (isAsyncIterable(streamLike)) {
+      return streamLike;
+    } else {
+      return asyncIterableFromStream(streamLike);
+    }
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/decodeAsync.cjs
+var require_decodeAsync = __commonJS((exports) => {
+  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_stream();
+  async function decodeAsync(streamLike, options) {
+    const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+    const decoder = new Decoder_ts_1.Decoder(options);
+    return decoder.decodeAsync(stream);
+  }
+  function decodeArrayStream(streamLike, options) {
+    const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+    const decoder = new Decoder_ts_1.Decoder(options);
+    return decoder.decodeArrayStream(stream);
+  }
+  function decodeMultiStream(streamLike, options) {
+    const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+    const decoder = new Decoder_ts_1.Decoder(options);
+    return decoder.decodeStream(stream);
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.2/node_modules/@msgpack/msgpack/dist.cjs/index.cjs
+var require_dist2 = __commonJS((exports) => {
+  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 = undefined;
+  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_timestamp();
+  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/.bun/robot3@0.4.1/node_modules/robot3/dist/machine.js
+var require_machine = __commonJS((exports) => {
+  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 identity = (a) => a;
+  var callBoth = (par, fn, self, args) => par.apply(self, args) && fn.apply(self, args);
+  var callForward = (par, fn, self, [a, b]) => fn.call(self, par.call(self, a, b), b);
+  var create = (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 create(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 filter(Type, arr) {
+    return arr.filter((value) => Type.isPrototypeOf(value));
+  }
+  function makeTransition(from, to, ...args) {
+    let guards = stack(filter(guardType, args).map((t) => t.fn), truthy, callBoth);
+    let reducers = stack(filter(reduceType, args).map((t) => t.fn), identity, callForward);
+    return create(this, {
+      from: valueEnumerable(from),
+      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 = 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: identity };
+  function state(...args) {
+    let transitions = filter(transitionType, args);
+    let immediates = filter(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 create(stateType, desc);
+  }
+  var invokeFnType = {
+    enter(machine2, service2, event) {
+      let rn = this.fn.call(service2, service2.context, event);
+      if (machine.isPrototypeOf(rn))
+        return create(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) ? create(invokeMachineType, {
+      machine: valueEnumerable(fn),
+      transitions: t
+    }) : create(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 create(machine, {
+      context: valueEnumerable(contextFn),
+      current: valueEnumerable(current),
+      states: valueEnumerable(states)
+    });
+  }
+  function transitionTo(service2, machine2, fromEvent, candidates) {
+    let { context } = service2;
+    for (let { to, guards, reducers } of candidates) {
+      if (guards(context, fromEvent)) {
+        service2.context = reducers.call(service2, context, fromEvent);
+        let original = machine2.original || machine2;
+        let newMachine = create(original, {
+          current: valueEnumerable(to),
+          original: { value: original }
+        });
+        if (d._onEnter)
+          d._onEnter(machine2, to, service2.context, context, fromEvent);
+        let state2 = newMachine.state.value;
+        return state2.enter(newMachine, service2, fromEvent);
+      }
+    }
+  }
+  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/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/realtime.js
+var require_realtime = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createRealtimeClient = createRealtimeClient;
+  var msgpack_1 = require_dist2();
+  var robot3_1 = require_machine();
+  var auth_1 = require_auth();
+  var response_1 = require_response();
+  var runtime_1 = require_runtime();
+  var utils_1 = require_utils3();
+  var initialState = () => ({
+    enqueuedMessage: undefined
+  });
+  function hasToken(context) {
+    return context.token !== undefined;
+  }
+  function noToken(context) {
+    return !hasToken(context);
+  }
+  function enqueueMessage(context, event) {
+    return Object.assign(Object.assign({}, context), { enqueuedMessage: event.message });
+  }
+  function closeConnection(context) {
+    if (context.websocket && context.websocket.readyState === WebSocket.OPEN) {
+      context.websocket.close();
+    }
+    return Object.assign(Object.assign({}, context), { websocket: undefined });
+  }
+  function sendMessage(context, event) {
+    if (context.websocket && context.websocket.readyState === WebSocket.OPEN) {
+      if (event.message instanceof Uint8Array) {
+        context.websocket.send(event.message);
+      } else {
+        context.websocket.send((0, msgpack_1.encode)(event.message));
+      }
+      return Object.assign(Object.assign({}, context), { enqueuedMessage: undefined });
+    }
+    return Object.assign(Object.assign({}, context), { enqueuedMessage: event.message });
+  }
+  function expireToken(context) {
+    return Object.assign(Object.assign({}, context), { token: undefined });
+  }
+  function setToken(context, event) {
+    return Object.assign(Object.assign({}, context), { token: event.token });
+  }
+  function connectionEstablished(context, event) {
+    return Object.assign(Object.assign({}, context), { 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)("expireToken", "idle", (0, robot3_1.reduce)(expireToken)), (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)("unauthorized", "idle", (0, robot3_1.reduce)(expireToken)), (0, robot3_1.transition)("connectionClosed", "idle", (0, robot3_1.reduce)(closeConnection)), (0, robot3_1.transition)("close", "idle", (0, robot3_1.reduce)(closeConnection))),
+    failed: (0, robot3_1.state)((0, robot3_1.transition)("send", "failed"), (0, robot3_1.transition)("close", "idle", (0, robot3_1.reduce)(closeConnection)))
+  }, initialState);
+  function buildRealtimeUrl(app, { token, maxBuffering }) {
+    if (maxBuffering !== undefined && (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 !== undefined) {
+      queryParams.set("max_buffering", maxBuffering.toFixed(0));
+    }
+    const appId = (0, utils_1.ensureEndpointIdFormat)(app);
+    return `wss://fal.run/${appId}/realtime?${queryParams.toString()}`;
+  }
+  var DEFAULT_THROTTLE_INTERVAL = 128;
+  function isUnauthorizedError(message) {
+    return message["status"] === "error" && message["error"] === "Unauthorized";
+  }
+  var WebSocketErrorCodes = {
+    NORMAL_CLOSURE: 1000,
+    GOING_AWAY: 1001
+  };
+  var connectionCache = new Map;
+  var connectionCallbacks = new Map;
+  function reuseInterpreter(key, throttleInterval, onChange) {
+    if (!connectionCache.has(key)) {
+      const machine = (0, robot3_1.interpret)(connectionStateMachine, onChange);
+      connectionCache.set(key, Object.assign(Object.assign({}, machine), { throttledSend: throttleInterval > 0 ? (0, utils_1.throttle)(machine.send, throttleInterval, true) : machine.send }));
+    }
+    return connectionCache.get(key);
+  }
+  var noop = () => {};
+  var NoOpConnection = {
+    send: noop,
+    close: noop
+  };
+  function isSuccessfulResult(data) {
+    return data.status !== "error" && data.type !== "x-fal-message" && !isFalErrorResult(data);
+  }
+  function isFalErrorResult(data) {
+    return data.type === "x-fal-error";
+  }
+  function createRealtimeClient({ config }) {
+    return {
+      connect(app, handler) {
+        const {
+          clientOnly = (0, utils_1.isReact)() && !(0, runtime_1.isBrowser)(),
+          connectionKey = crypto.randomUUID(),
+          maxBuffering,
+          throttleInterval = DEFAULT_THROTTLE_INTERVAL
+        } = handler;
+        if (clientOnly && !(0, runtime_1.isBrowser)()) {
+          return NoOpConnection;
+        }
+        let previousState;
+        connectionCallbacks.set(connectionKey, {
+          onError: handler.onError,
+          onResult: handler.onResult
+        });
+        const getCallbacks = () => connectionCallbacks.get(connectionKey);
+        const stateMachine = reuseInterpreter(connectionKey, throttleInterval, ({ context, machine, send: send2 }) => {
+          const { enqueuedMessage, token } = context;
+          if (machine.current === "active" && enqueuedMessage) {
+            send2({ type: "send", message: enqueuedMessage });
+          }
+          if (machine.current === "authRequired" && token === undefined && previousState !== machine.current) {
+            send2({ type: "initiateAuth" });
+            (0, auth_1.getTemporaryAuthToken)(app, config).then((token2) => {
+              send2({ type: "authenticated", token: token2 });
+              const tokenExpirationTimeout = Math.round(auth_1.TOKEN_EXPIRATION_SECONDS * 0.9 * 1000);
+              setTimeout(() => {
+                send2({ type: "expireToken" });
+              }, tokenExpirationTimeout);
+            }).catch((error) => {
+              send2({ type: "unauthorized", error });
+            });
+          }
+          if (machine.current === "connecting" && previousState !== machine.current && token !== undefined) {
+            const ws = new WebSocket(buildRealtimeUrl(app, { token, maxBuffering }));
+            ws.onopen = () => {
+              send2({ type: "connected", websocket: ws });
+            };
+            ws.onclose = (event) => {
+              if (event.code !== WebSocketErrorCodes.NORMAL_CLOSURE) {
+                const { onError = noop } = 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 = noop } = getCallbacks();
+              onError(new response_1.ApiError({ message: "Unknown error", status: 500 }));
+            };
+            ws.onmessage = (event) => {
+              const { onResult } = getCallbacks();
+              if (event.data instanceof ArrayBuffer) {
+                const result = (0, msgpack_1.decode)(new Uint8Array(event.data));
+                onResult(result);
+                return;
+              }
+              if (event.data instanceof Uint8Array) {
+                const result = (0, msgpack_1.decode)(event.data);
+                onResult(result);
+                return;
+              }
+              if (event.data instanceof Blob) {
+                event.data.arrayBuffer().then((buffer) => {
+                  const result = (0, msgpack_1.decode)(new Uint8Array(buffer));
+                  onResult(result);
+                });
+                return;
+              }
+              const data = JSON.parse(event.data);
+              if (isUnauthorizedError(data)) {
+                send2({
+                  type: "unauthorized",
+                  error: new Error("Unauthorized")
+                });
+                return;
+              }
+              if (isSuccessfulResult(data)) {
+                onResult(data);
+                return;
+              }
+              if (isFalErrorResult(data)) {
+                if (data.error === "TIMEOUT") {
+                  return;
+                }
+                const { onError = noop } = getCallbacks();
+                onError(new response_1.ApiError({
+                  message: `${data.error}: ${data.reason}`,
+                  status: 400,
+                  body: data
+                }));
+                return;
+              }
+            };
+          }
+          previousState = machine.current;
+        });
+        const send = (input) => {
+          stateMachine.throttledSend({
+            type: "send",
+            message: input
+          });
+        };
+        const close = () => {
+          stateMachine.send({ type: "close" });
+        };
+        return {
+          send,
+          close
+        };
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/client.js
+var require_client = __commonJS((exports) => {
+  var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, 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 ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createFalClient = createFalClient;
+  var config_1 = require_config();
+  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 createFalClient(userConfig = {}) {
+    const config = (0, config_1.createConfig)(userConfig);
+    const storage = (0, storage_1.createStorageClient)({ config });
+    const queue = (0, queue_1.createQueueClient)({ config, storage });
+    const streaming = (0, streaming_1.createStreamingClient)({ config, storage });
+    const realtime = (0, realtime_1.createRealtimeClient)({ config });
+    return {
+      queue,
+      realtime,
+      storage,
+      streaming,
+      stream: streaming.stream,
+      run(endpointId_1) {
+        return __awaiter(this, arguments, undefined, function* (endpointId, options = {}) {
+          const input = options.input ? yield storage.transformInput(options.input) : undefined;
+          return (0, request_1.dispatchRequest)({
+            method: options.method,
+            targetUrl: (0, request_1.buildUrl)(endpointId, options),
+            input,
+            headers: (0, storage_1.buildObjectLifecycleHeaders)(options.storageSettings),
+            config: Object.assign(Object.assign({}, config), { responseHandler: response_1.resultResponseHandler }),
+            options: {
+              signal: options.abortSignal,
+              retry: {
+                maxRetries: 3,
+                baseDelay: 500,
+                maxDelay: 15000
+              }
+            }
+          });
+        });
+      },
+      subscribe: (endpointId, options) => __awaiter(this, undefined, undefined, 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/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/types/common.js
+var require_common = __commonJS((exports) => {
+  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/.bun/@fal-ai+client@1.8.1/node_modules/@fal-ai/client/src/index.js
+var require_src2 = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      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 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(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 = undefined;
+  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;
+  } });
+  __exportStar(require_common(), exports);
+  var utils_1 = require_utils3();
+  Object.defineProperty(exports, "parseEndpointId", { enumerable: true, get: function() {
+    return utils_1.parseEndpointId;
+  } });
+  exports.fal = function createSingletonFalClient() {
+    let currentInstance = (0, client_1.createFalClient)();
+    return {
+      config(config) {
+        currentInstance = (0, client_1.createFalClient)(config);
+      },
+      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);
+      }
+    };
+  }();
+});
+
 // src/plugin.ts
 import { ModelType, logger } from "@elizaos/core";
 
@@ -1624,11 +5371,15 @@ var aiGatewayConfigSchema = z.object({
   AI_GATEWAY_TEXT_SMALL_MODEL: z.string().default("anthropic/claude-haiku-4.5"),
   AI_GATEWAY_TEXT_LARGE_MODEL: z.string().default("anthropic/claude-opus-4.5"),
   AI_GATEWAY_EMBEDDING_MODEL: z.string().default("openai/text-embedding-3-large"),
-  AI_GATEWAY_IMAGE_MODEL: z.string().default("bfl/flux-2-pro"),
+  AI_GATEWAY_IMAGE_MODEL: z.string().default("google/imagen-4.0-generate"),
   AI_GATEWAY_VISION_MODEL: z.string().default("xai/grok-2-vision"),
   AI_GATEWAY_TRANSCRIPTION_MODEL: z.string().default("openai/whisper-1"),
   AI_GATEWAY_TTS_MODEL: z.string().default("openai/tts-1-hd"),
-  AI_GATEWAY_TTS_VOICE: z.enum(["alloy", "echo", "fable", "onyx", "nova", "shimmer"]).default("alloy")
+  AI_GATEWAY_TTS_VOICE: z.enum(["alloy", "echo", "fable", "onyx", "nova", "shimmer"]).default("alloy"),
+  FAL_API_KEY: z.string().optional(),
+  FAL_IMAGE_MODEL: z.string().default("fal-ai/flux/dev"),
+  FAL_VIDEO_MODEL: z.string().default("fal-ai/minimax-video/image-to-video"),
+  FAL_PREFER_FOR_IMAGES: z.boolean().default(false)
 });
 function parseConfig(env) {
   return aiGatewayConfigSchema.parse({
@@ -1641,13 +5392,414 @@ function parseConfig(env) {
     AI_GATEWAY_VISION_MODEL: env.AI_GATEWAY_VISION_MODEL,
     AI_GATEWAY_TRANSCRIPTION_MODEL: env.AI_GATEWAY_TRANSCRIPTION_MODEL,
     AI_GATEWAY_TTS_MODEL: env.AI_GATEWAY_TTS_MODEL,
-    AI_GATEWAY_TTS_VOICE: env.AI_GATEWAY_TTS_VOICE
+    AI_GATEWAY_TTS_VOICE: env.AI_GATEWAY_TTS_VOICE,
+    FAL_API_KEY: env.FAL_API_KEY,
+    FAL_IMAGE_MODEL: env.FAL_IMAGE_MODEL,
+    FAL_VIDEO_MODEL: env.FAL_VIDEO_MODEL,
+    FAL_PREFER_FOR_IMAGES: env.FAL_PREFER_FOR_IMAGES === "true"
   });
 }
 function getConfigWithDefaults(partial) {
   return aiGatewayConfigSchema.parse(partial);
 }
 
+// src/handlers/fal-models.ts
+var FAL_API_BASE = "https://fal.ai/api";
+async function fetchFalModels(apiKey, filters = {}) {
+  const params = new URLSearchParams;
+  if (filters.query) {
+    params.set("q", filters.query);
+  }
+  if (filters.category) {
+    params.set("category", filters.category);
+  }
+  if (filters.status === "active") {
+    params.set("deprecated", "false");
+  } else if (filters.status === "deprecated") {
+    params.set("deprecated", "true");
+  }
+  if (filters.limit) {
+    params.set("limit", filters.limit.toString());
+  }
+  if (filters.cursor) {
+    params.set("cursor", filters.cursor);
+  }
+  const url = `${FAL_API_BASE}/models${params.toString() ? `?${params.toString()}` : ""}`;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Key ${apiKey}`;
+  }
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({ error: { message: response.statusText } }));
+    throw new Error(`FAL API error: ${errorData.error?.message || response.statusText}`);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    throw new Error("Failed to parse FAL API response");
+  }
+  if (filters.sort && data.items.length > 0) {
+    data.items = sortModels(data.items, filters.sort);
+  }
+  return data;
+}
+function sortModels(models, sort) {
+  return [...models].sort((a, b) => {
+    switch (sort) {
+      case "newest":
+        return new Date(b.date).getTime() - new Date(a.date).getTime();
+      case "oldest":
+        return new Date(a.date).getTime() - new Date(b.date).getTime();
+      case "highlighted":
+        if (b.highlighted !== a.highlighted) {
+          return b.highlighted ? 1 : -1;
+        }
+        return new Date(b.date).getTime() - new Date(a.date).getTime();
+      case "name":
+        return a.title.localeCompare(b.title);
+      default:
+        return 0;
+    }
+  });
+}
+async function fetchAllFalModels(apiKey, filters = {}, maxPages = 10) {
+  const allModels = [];
+  let cursor;
+  let pages = 0;
+  do {
+    const response = await fetchFalModels(apiKey, { ...filters, cursor });
+    allModels.push(...response.items);
+    cursor = response.nextCursor;
+    pages++;
+  } while (cursor && pages < maxPages);
+  if (filters.sort) {
+    return sortModels(allModels, filters.sort);
+  }
+  return allModels;
+}
+async function getImageModels(apiKey, options = {}) {
+  const response = await fetchFalModels(apiKey, {
+    status: "active",
+    sort: options.sort || "newest",
+    limit: 100
+  });
+  const imageModels = response.items.filter((m) => m.category === "text-to-image");
+  return imageModels.slice(0, options.limit || 50);
+}
+async function getVideoModels(apiKey, options = {}) {
+  const response = await fetchFalModels(apiKey, {
+    status: "active",
+    sort: options.sort || "newest",
+    limit: 100
+  });
+  const videoModels = response.items.filter((m) => m.category === "text-to-video" || m.category === "image-to-video");
+  return videoModels.slice(0, options.limit || 50);
+}
+async function get3DModels(apiKey, options = {}) {
+  const response = await fetchFalModels(apiKey, {
+    status: "active",
+    sort: options.sort || "newest",
+    limit: 100
+  });
+  const models3d = response.items.filter((m) => m.category === "image-to-3d" || m.category === "text-to-3d");
+  return models3d.slice(0, options.limit || 50);
+}
+async function searchModels(apiKey, query, options = {}) {
+  const response = await fetchFalModels(apiKey, {
+    query,
+    category: options.category,
+    status: "active",
+    sort: options.sort || "highlighted",
+    limit: options.limit || 50
+  });
+  return response.items;
+}
+async function getModel(apiKey, modelId) {
+  const url = `${FAL_API_BASE}/models?q=${encodeURIComponent(modelId)}&limit=1`;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Key ${apiKey}`;
+  }
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    if (response.status === 404) {
+      return null;
+    }
+    const errorData = await response.json().catch(() => ({ error: { message: response.statusText } }));
+    throw new Error(`FAL API error: ${errorData.error?.message || response.statusText}`);
+  }
+  const data = await response.json();
+  return data.items.find((m) => m.id === modelId) || data.items[0] || null;
+}
+function formatModelDisplay(m) {
+  const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+  return `${m.title} (${m.id})${tags}`;
+}
+function createFalModelsProvider(config) {
+  return {
+    name: "FAL_MODELS",
+    description: "Provides information about available FAL.ai models for image, video, and 3D generation",
+    position: 50,
+    get: async () => {
+      if (!config.FAL_API_KEY) {
+        return {
+          text: "FAL models: Not configured (FAL_API_KEY not set)",
+          data: { configured: false }
+        };
+      }
+      try {
+        const [imageModels, videoModels] = await Promise.all([
+          getImageModels(config.FAL_API_KEY, { sort: "highlighted", limit: 5 }),
+          getVideoModels(config.FAL_API_KEY, { sort: "highlighted", limit: 5 })
+        ]);
+        const text = `FAL.ai Models Available:
+
+**Image Generation (text-to-image):**
+${imageModels.map((m) => `- ${formatModelDisplay(m)}`).join(`
+`)}
+
+**Video Generation:**
+${videoModels.map((m) => `- ${formatModelDisplay(m)}`).join(`
+`)}
+
+Current defaults:
+- Image: ${config.FAL_IMAGE_MODEL}
+- Video: ${config.FAL_VIDEO_MODEL}`;
+        return {
+          text,
+          data: {
+            configured: true,
+            imageModels: imageModels.map((m) => ({
+              id: m.id,
+              name: m.title,
+              tags: m.tags
+            })),
+            videoModels: videoModels.map((m) => ({
+              id: m.id,
+              name: m.title,
+              tags: m.tags
+            })),
+            currentDefaults: {
+              image: config.FAL_IMAGE_MODEL,
+              video: config.FAL_VIDEO_MODEL
+            }
+          }
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          text: `FAL models: Error fetching models - ${message}`,
+          data: { configured: true, error: message }
+        };
+      }
+    }
+  };
+}
+
+// src/actions/list-fal-models.ts
+function formatModel(model) {
+  const tags = model.tags.length > 0 ? ` [${model.tags.join(", ")}]` : "";
+  const status = model.deprecated ? " (DEPRECATED)" : "";
+  const updated = model.date ? ` - Added: ${new Date(model.date).toLocaleDateString()}` : "";
+  return `- **${model.title}** (${model.id})${tags}${status}${updated}
+  ${model.shortDescription || ""}`;
+}
+var listFalModelsAction = {
+  name: "LIST_FAL_MODELS",
+  description: "Search and list available FAL.ai models for image, video, and 3D generation. Use this to discover the newest and best models.",
+  similes: [
+    "list fal models",
+    "show fal models",
+    "search fal models",
+    "get fal models",
+    "find fal models",
+    "what models are available",
+    "newest models",
+    "latest models",
+    "best image models",
+    "best video models"
+  ],
+  examples: [
+    [
+      {
+        name: "user",
+        content: { text: "What are the newest image generation models on FAL?" }
+      },
+      {
+        name: "assistant",
+        content: { text: "Let me search for the newest FAL image models...", action: "LIST_FAL_MODELS" }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: { text: "Show me video generation models" }
+      },
+      {
+        name: "assistant",
+        content: { text: "I'll list the available video generation models on FAL...", action: "LIST_FAL_MODELS" }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: { text: "Search for FLUX models" }
+      },
+      {
+        name: "assistant",
+        content: { text: "Searching FAL for FLUX models...", action: "LIST_FAL_MODELS" }
+      }
+    ]
+  ],
+  validate: async (_runtime, message, _state) => {
+    const text = message.content?.text?.toLowerCase() || "";
+    const keywords = [
+      "fal model",
+      "models available",
+      "list model",
+      "show model",
+      "search model",
+      "find model",
+      "what model",
+      "which model",
+      "image model",
+      "video model",
+      "3d model",
+      "newest model",
+      "latest model",
+      "best model",
+      "flux",
+      "minimax",
+      "luma",
+      "stable diffusion"
+    ];
+    return keywords.some((keyword) => text.includes(keyword));
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const text = message.content?.text?.toLowerCase() || "";
+    const settingValue = runtime.getSetting("FAL_API_KEY");
+    const apiKey = typeof settingValue === "string" ? settingValue : process.env.FAL_API_KEY;
+    if (!apiKey) {
+      if (callback) {
+        await callback({
+          text: "FAL API key is not configured. Please set FAL_API_KEY to use model discovery.",
+          action: "LIST_FAL_MODELS"
+        });
+      }
+      return { success: false, data: { error: "FAL_API_KEY not configured" } };
+    }
+    try {
+      let category = "all";
+      if (text.includes("image") || text.includes("picture") || text.includes("photo")) {
+        category = "image";
+      } else if (text.includes("video") || text.includes("animation")) {
+        category = "video";
+      } else if (text.includes("3d") || text.includes("three-d") || text.includes("mesh")) {
+        category = "3d";
+      }
+      let sort = "highlighted";
+      if (text.includes("newest") || text.includes("latest") || text.includes("recent")) {
+        sort = "newest";
+      } else if (text.includes("oldest")) {
+        sort = "oldest";
+      } else if (text.includes("name") || text.includes("alphabetical")) {
+        sort = "name";
+      }
+      const searchMatch = text.match(/search(?:\s+for)?\s+["']?([^"']+)["']?/i);
+      const queryMatch = text.match(/(?:find|show|list)\s+(?:me\s+)?["']?([a-zA-Z0-9\s]+)["']?\s+models?/i);
+      const searchQuery = searchMatch?.[1] || queryMatch?.[1];
+      let models = [];
+      let categoryLabel = "";
+      if (searchQuery) {
+        models = await searchModels(apiKey, searchQuery.trim(), { sort, limit: 20 });
+        categoryLabel = `Search results for "${searchQuery.trim()}"`;
+      } else if (category === "image") {
+        models = await getImageModels(apiKey, { sort, limit: 15 });
+        categoryLabel = "Image Generation Models (text-to-image)";
+      } else if (category === "video") {
+        models = await getVideoModels(apiKey, { sort, limit: 15 });
+        categoryLabel = "Video Generation Models";
+      } else if (category === "3d") {
+        models = await get3DModels(apiKey, { sort, limit: 15 });
+        categoryLabel = "3D Generation Models (image-to-3d)";
+      } else {
+        const [imageModels, videoModels] = await Promise.all([
+          getImageModels(apiKey, { sort, limit: 8 }),
+          getVideoModels(apiKey, { sort, limit: 8 })
+        ]);
+        const responseText2 = `**FAL.ai Available Models** (sorted by ${sort})
+
+## Image Generation (text-to-image)
+${imageModels.map(formatModel).join(`
+`)}
+
+## Video Generation
+${videoModels.map(formatModel).join(`
+`)}
+
+Use more specific queries like "show newest image models" or "search for FLUX models" for targeted results.`;
+        if (callback) {
+          await callback({
+            text: responseText2,
+            action: "LIST_FAL_MODELS"
+          });
+        }
+        return {
+          success: true,
+          data: {
+            imageModels: imageModels.map((m) => m.id),
+            videoModels: videoModels.map((m) => m.id),
+            sort
+          }
+        };
+      }
+      const responseText = `**${categoryLabel}** (sorted by ${sort})
+
+${models.length > 0 ? models.map(formatModel).join(`
+
+`) : "No models found matching your criteria."}
+
+Total: ${models.length} model${models.length !== 1 ? "s" : ""}`;
+      if (callback) {
+        await callback({
+          text: responseText,
+          action: "LIST_FAL_MODELS"
+        });
+      }
+      return {
+        success: true,
+        data: {
+          category,
+          sort,
+          searchQuery,
+          models: models.map((m) => ({
+            id: m.id,
+            name: m.title,
+            category: m.category,
+            tags: m.tags,
+            date: m.date
+          })),
+          count: models.length
+        }
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Unknown error";
+      if (callback) {
+        await callback({
+          text: `Failed to fetch FAL models: ${errorMessage}`,
+          action: "LIST_FAL_MODELS"
+        });
+      }
+      return { success: false, data: { error: errorMessage } };
+    }
+  }
+};
 // ../../node_modules/.bun/@ai-sdk+provider@1.1.3/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
 var symbol = Symbol.for(marker);
@@ -10703,11 +14855,13 @@ function createTextEmbeddingHandler(config) {
     if (!text2 || text2.trim().length === 0) {
       return new Array(3072).fill(0);
     }
+    console.log(`[AI Gateway] Generating embedding for text (${text2.length} chars)`);
     const model = getEmbeddingModel(config, config.AI_GATEWAY_EMBEDDING_MODEL);
     const result = await embed({
       model,
       value: text2
     });
+    console.log(`[AI Gateway] Embedding generated (${result.embedding.length} dimensions)`);
     return result.embedding;
   };
 }
@@ -11261,11 +15415,86 @@ function createTokenizerDecodeHandler() {
     return tokenizer.decode(detokenParams.tokens);
   };
 }
+// src/handlers/fal.ts
+var import_client = __toESM(require_src2(), 1);
+function initFalClient(apiKey) {
+  import_client.fal.config({
+    credentials: apiKey
+  });
+}
+function createFalImageHandler(config) {
+  return async (_runtime, params) => {
+    if (!config.FAL_API_KEY) {
+      throw new Error("FAL_API_KEY is required for FAL image generation");
+    }
+    initFalClient(config.FAL_API_KEY);
+    const imageParams = params;
+    let width = 1024;
+    let height = 1024;
+    if (imageParams.size) {
+      const [w, h] = imageParams.size.split("x").map(Number);
+      if (w && h) {
+        width = w;
+        height = h;
+      }
+    }
+    const result = await import_client.fal.subscribe(config.FAL_IMAGE_MODEL, {
+      input: {
+        prompt: imageParams.prompt,
+        image_size: {
+          width,
+          height
+        },
+        num_images: imageParams.count || 1
+      }
+    });
+    const images = result.data?.images || [result.data];
+    return images.map((img) => ({ url: img.url }));
+  };
+}
+function createFalVideoHandler(config) {
+  return async (_runtime, params) => {
+    if (!config.FAL_API_KEY) {
+      throw new Error("FAL_API_KEY is required for FAL video generation");
+    }
+    initFalClient(config.FAL_API_KEY);
+    const videoParams = params;
+    const input = {
+      prompt: videoParams.prompt
+    };
+    if (videoParams.image_url) {
+      input.image_url = videoParams.image_url;
+    }
+    const result = await import_client.fal.subscribe(config.FAL_VIDEO_MODEL, {
+      input
+    });
+    const data = result.data;
+    const videoUrl = data.video?.url || data.url;
+    if (!videoUrl) {
+      throw new Error("No video URL returned from FAL");
+    }
+    return { url: videoUrl };
+  };
+}
+var FAL_MODELS = {
+  IMAGE: {
+    FLUX_DEV: "fal-ai/flux/dev",
+    FLUX_PRO: "fal-ai/flux-pro",
+    FLUX_SCHNELL: "fal-ai/flux/schnell",
+    RECRAFT_V3: "fal-ai/recraft-v3",
+    SD_V35_LARGE: "fal-ai/stable-diffusion-v35-large"
+  },
+  VIDEO: {
+    MINIMAX: "fal-ai/minimax-video/image-to-video",
+    LUMA_DREAM_MACHINE: "fal-ai/luma-dream-machine/image-to-video",
+    KLING_V1: "fal-ai/kling-video/v1/standard/image-to-video"
+  }
+};
 // src/plugin.ts
 var PLUGIN_NAME = "@ghostspeak/plugin-gateway-ghost";
 var PRIORITY = 10;
 function createModelHandlers(config) {
-  return {
+  const handlers = {
     [ModelType.TEXT_SMALL]: {
       handler: createTextSmallHandler(config),
       provider: PLUGIN_NAME,
@@ -11307,7 +15536,7 @@ function createModelHandlers(config) {
       priority: PRIORITY
     },
     [ModelType.IMAGE]: {
-      handler: createImageHandler(config),
+      handler: config.FAL_API_KEY && config.FAL_PREFER_FOR_IMAGES ? createFalImageHandler(config) : createImageHandler(config),
       provider: PLUGIN_NAME,
       priority: PRIORITY
     },
@@ -11337,7 +15566,16 @@ function createModelHandlers(config) {
       priority: PRIORITY
     }
   };
+  if (config.FAL_API_KEY) {
+    handlers[ModelType.VIDEO] = {
+      handler: createFalVideoHandler(config),
+      provider: PLUGIN_NAME,
+      priority: PRIORITY
+    };
+  }
+  return handlers;
 }
+var pluginConfigCache = null;
 var aiGatewayPlugin = {
   name: PLUGIN_NAME,
   description: "Unified Vercel AI Gateway - one API key for all models (Claude, FLUX, Grok Vision, Whisper, etc.)",
@@ -11353,8 +15591,13 @@ var aiGatewayPlugin = {
         AI_GATEWAY_VISION_MODEL: pluginConfig.AI_GATEWAY_VISION_MODEL || process.env.AI_GATEWAY_VISION_MODEL,
         AI_GATEWAY_TRANSCRIPTION_MODEL: pluginConfig.AI_GATEWAY_TRANSCRIPTION_MODEL || process.env.AI_GATEWAY_TRANSCRIPTION_MODEL,
         AI_GATEWAY_TTS_MODEL: pluginConfig.AI_GATEWAY_TTS_MODEL || process.env.AI_GATEWAY_TTS_MODEL,
-        AI_GATEWAY_TTS_VOICE: pluginConfig.AI_GATEWAY_TTS_VOICE || process.env.AI_GATEWAY_TTS_VOICE
+        AI_GATEWAY_TTS_VOICE: pluginConfig.AI_GATEWAY_TTS_VOICE || process.env.AI_GATEWAY_TTS_VOICE,
+        FAL_API_KEY: pluginConfig.FAL_API_KEY || process.env.FAL_API_KEY,
+        FAL_IMAGE_MODEL: pluginConfig.FAL_IMAGE_MODEL || process.env.FAL_IMAGE_MODEL,
+        FAL_VIDEO_MODEL: pluginConfig.FAL_VIDEO_MODEL || process.env.FAL_VIDEO_MODEL,
+        FAL_PREFER_FOR_IMAGES: pluginConfig.FAL_PREFER_FOR_IMAGES || process.env.FAL_PREFER_FOR_IMAGES
       });
+      pluginConfigCache = config;
       const handlers = createModelHandlers(config);
       for (const [modelType, registration] of Object.entries(handlers)) {
         runtime.registerModel(modelType, registration.handler, registration.provider, registration.priority);
@@ -11364,14 +15607,34 @@ var aiGatewayPlugin = {
         models: Object.keys(handlers).length,
         textSmall: config.AI_GATEWAY_TEXT_SMALL_MODEL,
         textLarge: config.AI_GATEWAY_TEXT_LARGE_MODEL,
-        image: config.AI_GATEWAY_IMAGE_MODEL,
-        vision: config.AI_GATEWAY_VISION_MODEL
+        image: config.FAL_API_KEY && config.FAL_PREFER_FOR_IMAGES ? `FAL: ${config.FAL_IMAGE_MODEL}` : config.AI_GATEWAY_IMAGE_MODEL,
+        video: config.FAL_API_KEY ? config.FAL_VIDEO_MODEL : "not configured",
+        vision: config.AI_GATEWAY_VISION_MODEL,
+        falEnabled: !!config.FAL_API_KEY
       }, "AI Gateway plugin initialized");
     } catch (error) {
       logger.error({ error, plugin: PLUGIN_NAME }, "Failed to initialize AI Gateway plugin");
       throw error;
     }
   },
+  providers: [
+    {
+      name: "FAL_MODELS",
+      description: "Provides information about available FAL.ai models for image, video, and 3D generation",
+      position: 50,
+      get: async () => {
+        if (!pluginConfigCache?.FAL_API_KEY) {
+          return {
+            text: "FAL models: Not configured (FAL_API_KEY not set)",
+            data: { configured: false }
+          };
+        }
+        const provider = createFalModelsProvider(pluginConfigCache);
+        return provider.get();
+      }
+    }
+  ],
+  actions: [listFalModelsAction],
   models: {}
 };
 var plugin_default = aiGatewayPlugin;
@@ -11401,12 +15664,20 @@ function isAuthError(error) {
   return false;
 }
 export {
+  searchModels,
   parseConfig,
+  listFalModelsAction,
   isRateLimitError,
   isAuthError,
+  getVideoModels,
+  getModel,
   getLanguageModel,
+  getImageModels,
   getEmbeddingModel,
   getConfigWithDefaults,
+  get3DModels,
+  fetchFalModels,
+  fetchAllFalModels,
   plugin_default as default,
   createTranscriptionHandler,
   createTokenizerEncodeHandler,
@@ -11423,11 +15694,15 @@ export {
   createImageHandler,
   createImageDescriptionHandler,
   createGatewayClient,
+  createFalVideoHandler,
+  createFalModelsProvider,
+  createFalImageHandler,
   clearGatewayCache,
   aiGatewayPlugin,
   aiGatewayConfigSchema,
+  FAL_MODELS,
   AIGatewayError
 };
 
-//# debugId=ACCB992F3D6D8F7064756E2164756E21
+//# debugId=3480F6C08AEEFBD264756E2164756E21
 //# sourceMappingURL=index.js.map