qarpeo 0.0.0-alpha.10

package/dist/runtime/email.mjs

@@ -0,0 +1,245 @@
+import { getCloudflareEnv, resolveRuntimeBinding } from "./bindings.mjs";
+export function parseSenderIdentity(key, raw) {
+  const trimmed = raw.trim();
+  const match = trimmed.match(/^(?:(?:"?([^"]*)"?\s)?<([^>]+)>|([^<>\s]+))$/);
+  if (match) {
+    const name = match[1]?.trim();
+    const address = (match[2] || match[3] || trimmed).trim();
+    return {
+      key,
+      address,
+      name: name || void 0,
+      label: trimmed
+    };
+  }
+  return {
+    key,
+    address: trimmed,
+    label: trimmed
+  };
+}
+export function useEmailSenders() {
+  const procEnv = globalThis.process?.env || {};
+  const publicConfig = globalThis.__NUXT_RUNTIME_CONFIG__?.public?.qarpeo?.email?.senders || globalThis.__qarpeo_senders__;
+  if (Array.isArray(publicConfig) && publicConfig.length > 0) {
+    return {
+      senders: publicConfig,
+      defaultSender: publicConfig.find((s) => s.key === "default") || publicConfig[0] || null,
+      getSender: (target) => {
+        const lower = target.toLowerCase();
+        return publicConfig.find(
+          (s) => s.key.toLowerCase() === lower || s.address.toLowerCase() === lower
+        );
+      }
+    };
+  }
+  let rawSenders = {};
+  if (procEnv.QARPEO_EMAIL_SENDERS) {
+    try {
+      rawSenders = JSON.parse(procEnv.QARPEO_EMAIL_SENDERS);
+    } catch {
+    }
+  } else if (procEnv.QARPEO_EMAIL_FROM) {
+    rawSenders = { default: procEnv.QARPEO_EMAIL_FROM };
+  }
+  const senders = Object.entries(rawSenders).map(
+    ([key, val]) => parseSenderIdentity(key, val)
+  );
+  const defaultSender = senders.find((s) => s.key === "default") || senders[0] || null;
+  const getSender = (target) => {
+    const lower = target.toLowerCase();
+    return senders.find((s) => s.key.toLowerCase() === lower || s.address.toLowerCase() === lower);
+  };
+  return {
+    senders,
+    defaultSender,
+    getSender
+  };
+}
+export function getEmailBinding(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("email", bindingName, "EMAIL");
+  const env = getCloudflareEnv(event);
+  const binding = env[resolvedBinding];
+  if (!binding) {
+    throw new Error(
+      `[qarpeo] Cloudflare send_email binding "${resolvedBinding}" was not found. Ensure email: true is configured in your nuxt.config.ts.`
+    );
+  }
+  return binding;
+}
+export function buildMimeMessage(options) {
+  const toStr = Array.isArray(options.to) ? options.to.join(", ") : options.to;
+  const messageId = options.messageId || `<${Date.now()}.${Math.random().toString(36).slice(2)}@qarpeo>`;
+  const date = (/* @__PURE__ */ new Date()).toUTCString();
+  const headers = [
+    `From: ${options.from}`,
+    `To: ${toStr}`,
+    `Subject: ${options.subject}`,
+    `Date: ${date}`,
+    `Message-ID: ${messageId}`,
+    `MIME-Version: 1.0`
+  ];
+  if (options.cc) {
+    headers.push(`Cc: ${Array.isArray(options.cc) ? options.cc.join(", ") : options.cc}`);
+  }
+  if (options.bcc) {
+    headers.push(`Bcc: ${Array.isArray(options.bcc) ? options.bcc.join(", ") : options.bcc}`);
+  }
+  if (options.replyTo) {
+    headers.push(`Reply-To: ${options.replyTo}`);
+  }
+  if (options.headers) {
+    for (const [k, v] of Object.entries(options.headers)) {
+      headers.push(`${k}: ${v}`);
+    }
+  }
+  if (options.html && options.text) {
+    const boundary = `_qarpeo_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    headers.push(`Content-Type: multipart/alternative; boundary="${boundary}"`);
+    const body = [
+      `--${boundary}`,
+      `Content-Type: text/plain; charset=UTF-8`,
+      `Content-Transfer-Encoding: 7bit`,
+      ``,
+      options.text,
+      ``,
+      `--${boundary}`,
+      `Content-Type: text/html; charset=UTF-8`,
+      `Content-Transfer-Encoding: 7bit`,
+      ``,
+      options.html,
+      ``,
+      `--${boundary}--`
+    ].join("\r\n");
+    return `${headers.join("\r\n")}\r
+\r
+${body}`;
+  } else if (options.html) {
+    headers.push(`Content-Type: text/html; charset=UTF-8`);
+    headers.push(`Content-Transfer-Encoding: 7bit`);
+    return `${headers.join("\r\n")}\r
+\r
+${options.html}`;
+  } else {
+    headers.push(`Content-Type: text/plain; charset=UTF-8`);
+    headers.push(`Content-Transfer-Encoding: 7bit`);
+    return `${headers.join("\r\n")}\r
+\r
+${options.text || ""}`;
+  }
+}
+function extractEmailAddress(raw) {
+  const match = raw.match(/<([^>]+)>/);
+  return match ? match[1].trim() : raw.trim();
+}
+function logDevMailbox(from, to, subject, text, html, messageId) {
+  const toDisplay = Array.isArray(to) ? to.join(", ") : to;
+  const bar = "\u2500".repeat(60);
+  console.log(`
+\u250C\u2500 \u{1F4E7} [qarpeo:email] Local Mailbox Intercept ${bar.slice(38)}\u2510`);
+  console.log(`\u2502 ID:      ${messageId || "n/a"}`);
+  console.log(`\u2502 From:    ${from}`);
+  console.log(`\u2502 To:      ${toDisplay}`);
+  console.log(`\u2502 Subject: ${subject}`);
+  console.log(`\u251C${bar}\u2524`);
+  const content = text || html?.replace(/<[^>]+>/g, " ").trim() || "(empty message)";
+  const lines = content.split("\n");
+  for (const line of lines.slice(0, 15)) {
+    console.log(`\u2502 ${line.slice(0, 58)}`);
+  }
+  if (lines.length > 15) {
+    console.log(`\u2502 ... (${lines.length - 15} more lines)`);
+  }
+  console.log(`\u2514${bar}\u2518
+`);
+}
+export async function sendEmail(options, event) {
+  const resolvedBinding = resolveRuntimeBinding("email", options.binding, "EMAIL");
+  const procEnv = globalThis.process?.env || {};
+  let senderPresets = {};
+  if (procEnv.QARPEO_EMAIL_SENDERS) {
+    try {
+      senderPresets = JSON.parse(procEnv.QARPEO_EMAIL_SENDERS);
+    } catch {
+    }
+  }
+  let rawFrom = options.from;
+  if (rawFrom && senderPresets[rawFrom]) {
+    rawFrom = senderPresets[rawFrom];
+  }
+  const from = rawFrom || senderPresets.default || procEnv.QARPEO_EMAIL_FROM || procEnv.EMAIL_FROM || "noreply@qarpeo.local";
+  if (!options.to || Array.isArray(options.to) && options.to.length === 0) {
+    throw new Error("[qarpeo:email] Recipient address 'to' is required.");
+  }
+  if (!options.subject) {
+    throw new Error("[qarpeo:email] Email 'subject' is required.");
+  }
+  const messageId = `<${Date.now()}.${Math.random().toString(36).slice(2)}@qarpeo>`;
+  const env = getCloudflareEnv(event);
+  const binding = env[resolvedBinding];
+  const isDev = procEnv.NODE_ENV !== "production" && !globalThis.__qarpeo_prod__ && (!binding || typeof binding.send !== "function");
+  if (isDev) {
+    logDevMailbox(from, options.to, options.subject, options.text, options.html, messageId);
+    const devMailboxArr = globalThis.__qarpeo_dev_mailbox__ ||= [];
+    devMailboxArr.unshift({
+      id: messageId,
+      to: options.to,
+      from,
+      subject: options.subject,
+      html: options.html || "",
+      text: options.text || "",
+      timestamp: Date.now(),
+      headers: options.headers
+    });
+    if (devMailboxArr.length > 100) {
+      devMailboxArr.pop();
+    }
+    return {
+      success: true,
+      id: messageId,
+      message: "Intercepted by local development mailbox"
+    };
+  }
+  if (!binding || typeof binding.send !== "function") {
+    throw new Error(
+      `[qarpeo:email] Cloudflare send_email binding "${resolvedBinding}" is not available. Make sure email: true is enabled and deployed to Cloudflare Workers.`
+    );
+  }
+  const cleanFrom = extractEmailAddress(from);
+  const toArr = Array.isArray(options.to) ? options.to : [options.to];
+  const bccArr = options.bcc ? Array.isArray(options.bcc) ? options.bcc : [options.bcc] : [];
+  const cleanTo = [...toArr, ...bccArr].map((addr) => extractEmailAddress(String(addr))).filter(Boolean);
+  const rawMime = buildMimeMessage({
+    ...options,
+    from,
+    messageId
+  });
+  try {
+    const EmailMessageClass = globalThis.EmailMessage;
+    if (typeof EmailMessageClass === "function") {
+      const msg = new EmailMessageClass(cleanFrom, cleanTo, rawMime);
+      await binding.send(msg);
+    } else {
+      await binding.send({
+        from: cleanFrom,
+        to: cleanTo,
+        raw: rawMime
+      });
+    }
+    return {
+      success: true,
+      id: messageId
+    };
+  } catch (err) {
+    throw new Error(`[qarpeo:email] Failed to send email via Cloudflare: ${err?.message || err}`);
+  }
+}
+export function createEmail(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("email", bindingName, "EMAIL");
+  return {
+    send: (opts) => sendEmail({ ...opts, binding: opts.binding || resolvedBinding }, event),
+    raw: (bName) => getEmailBinding(bName || resolvedBinding, event)
+  };
+}
+export const useEmail = createEmail;
+export const email = createEmail();

package/dist/runtime/hyperdrive.d.ts

@@ -0,0 +1,21 @@
+import type { QarpeoHyperdrive, HyperdriveBinding } from "./types/hyperdrive";
+import type { CFEvent } from "./types/index";
+export type * from "./types/hyperdrive";
+/**
+ * Returns the raw Cloudflare Hyperdrive binding from the active environment.
+ *
+ * @param bindingName Optional Cloudflare Hyperdrive binding name (defaults to 'HYPERDRIVE')
+ * @param event Optional event context
+ */
+export declare function getHyperdriveBinding(bindingName?: string, event?: CFEvent): HyperdriveBinding;
+/** Creates a typed Hyperdrive client for a specific binding and optional event. */
+export declare function createHyperdrive(bindingName?: string, event?: CFEvent): QarpeoHyperdrive;
+/**
+ * Access a typed Cloudflare Hyperdrive client.
+ *
+ * @param bindingName Optional Hyperdrive binding name (defaults to 'HYPERDRIVE')
+ * @param event Optional event context
+ */
+export declare const useHyperdrive: (bindingName?: string, event?: CFEvent) => QarpeoHyperdrive;
+/** Auto-imported `hyperdrive` instance for direct Cloudflare Hyperdrive connection properties. */
+export declare const hyperdrive: QarpeoHyperdrive;

package/dist/runtime/hyperdrive.mjs

@@ -0,0 +1,49 @@
+import { getCloudflareEnv, resolveRuntimeBinding } from "./bindings.mjs";
+export function getHyperdriveBinding(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("hyperdrive", bindingName, "HYPERDRIVE");
+  const env = getCloudflareEnv(event);
+  const binding = env[resolvedBinding];
+  if (!binding) {
+    throw new Error(
+      `[qarpeo] Cloudflare Hyperdrive binding "${resolvedBinding}" was not found. Check your wrangler.json or QARPEO_HYPERDRIVE_BINDING environment variable.`
+    );
+  }
+  return binding;
+}
+export function createHyperdrive(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("hyperdrive", bindingName, "HYPERDRIVE");
+  const getHd = () => getHyperdriveBinding(resolvedBinding, event);
+  return {
+    get connectionString() {
+      return getHd().connectionString;
+    },
+    get host() {
+      return getHd().host;
+    },
+    get port() {
+      return getHd().port;
+    },
+    get user() {
+      return getHd().user;
+    },
+    get password() {
+      return getHd().password;
+    },
+    get database() {
+      return getHd().database;
+    },
+    raw: (bName) => {
+      return getHyperdriveBinding(bName || resolvedBinding, event);
+    }
+  };
+}
+export const useHyperdrive = createHyperdrive;
+export const hyperdrive = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "raw") {
+      return (bindingName) => getHyperdriveBinding(bindingName);
+    }
+    const instance = createHyperdrive();
+    return instance[prop];
+  }
+});

package/dist/runtime/index.d.ts

@@ -0,0 +1,23 @@
+export * from "./types/index";
+export * from "./bindings";
+export * from "./kv";
+export * from "./blob";
+export * from "./db";
+export * from "./drizzle";
+export * from "./email";
+export * from "./cache";
+export * from "./ai";
+export * from "./vectorize";
+export * from "./queue";
+export * from "./analytics";
+export * from "./ratelimit";
+export * from "./hyperdrive";
+export * from "./browser";
+export * from "./auth";
+export * from "./realtime";
+export * from "./cms";
+export * from "./payments";
+export * from "./storage";
+export * from "./bots";
+export * from "./rag";
+export * from "./app/composables/site";

package/dist/runtime/index.mjs

@@ -0,0 +1,23 @@
+export * from "./types/index.mjs";
+export * from "./bindings.mjs";
+export * from "./kv.mjs";
+export * from "./blob.mjs";
+export * from "./db.mjs";
+export * from "./drizzle.mjs";
+export * from "./email.mjs";
+export * from "./cache.mjs";
+export * from "./ai.mjs";
+export * from "./vectorize.mjs";
+export * from "./queue.mjs";
+export * from "./analytics.mjs";
+export * from "./ratelimit.mjs";
+export * from "./hyperdrive.mjs";
+export * from "./browser.mjs";
+export * from "./auth.mjs";
+export * from "./realtime.mjs";
+export * from "./cms.mjs";
+export * from "./payments.mjs";
+export * from "./storage.mjs";
+export * from "./bots.mjs";
+export * from "./rag.mjs";
+export * from "./app/composables/site.mjs";

package/dist/runtime/kv.d.ts

@@ -0,0 +1,16 @@
+import type { CFEvent, QarpeoKV, KVNamespace } from "./types";
+/** Returns the raw Cloudflare KVNamespace binding from the active environment. */
+export declare function getKVBinding(bindingName?: string, event?: CFEvent): KVNamespace;
+/** Creates a typed KV interface for a specific binding and optional event. */
+export declare function createKV(bindingName?: string, event?: CFEvent): QarpeoKV;
+/**
+ * Access a typed Cloudflare KV instance.
+ *
+ * @param bindingName Optional KV binding name (defaults to configured binding or 'KV')
+ * @param event Optional event context
+ */
+export declare const useKV: (bindingName?: string, event?: CFEvent) => QarpeoKV;
+/** Auto-imported `kv` instance for direct Cloudflare KV operations. */
+export declare const kv: QarpeoKV;
+/** Alias for getKVBinding for compatibility with nitro storage naming conventions. */
+export declare const getKVStorage: (bindingName?: string, event?: CFEvent) => KVNamespace;

package/dist/runtime/kv.mjs

@@ -0,0 +1,126 @@
+import { getCloudflareEnv, resolveRuntimeBinding } from "./bindings.mjs";
+export function getKVBinding(bindingName, event) {
+  const resolved = resolveRuntimeBinding("kv", bindingName, "KV");
+  const env = getCloudflareEnv(event);
+  const binding = env[resolved];
+  if (!binding) {
+    throw new Error(
+      `[qarpeo] Cloudflare KV binding "${resolved}" was not found. Check your wrangler.json or qarpeo.kv configuration.`
+    );
+  }
+  return binding;
+}
+function serialize(value) {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function deserialize(raw) {
+  if (raw === null) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+async function listAllKeys(kvBinding, prefix) {
+  const keys = [];
+  let cursor;
+  do {
+    const result = await kvBinding.list({
+      prefix,
+      cursor,
+      limit: 1e3
+    });
+    keys.push(...result.keys);
+    cursor = result.list_complete ? void 0 : result.cursor;
+  } while (cursor);
+  return keys;
+}
+export function createKV(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("kv", bindingName, "KV");
+  const getKV = () => getKVBinding(resolvedBinding, event);
+  return {
+    // -------------------------------------------------------------------------
+    // Core — auto JSON
+    // -------------------------------------------------------------------------
+    get: async (key, options) => {
+      const kv2 = getKV();
+      const type = options?.type ?? "json";
+      const cacheTtl = options?.cacheTtl;
+      if (type === "json") {
+        const raw = await kv2.get(key, { type: "text", cacheTtl });
+        return deserialize(raw);
+      }
+      const result = await kv2.get(key, { type, cacheTtl });
+      return result;
+    },
+    set: async (key, value, options) => {
+      const kv2 = getKV();
+      const raw = serialize(value);
+      await kv2.put(key, raw, {
+        expirationTtl: options?.ttl ?? options?.ex,
+        expiration: options?.expiration,
+        metadata: options?.metadata ?? null
+      });
+    },
+    has: async (key) => {
+      const kv2 = getKV();
+      const val = await kv2.get(key, { type: "text" });
+      return val !== null;
+    },
+    delete: async (key) => {
+      const kv2 = getKV();
+      await kv2.delete(key);
+      return true;
+    },
+    del: async (key) => {
+      const kv2 = getKV();
+      await kv2.delete(key);
+      return true;
+    },
+    // -------------------------------------------------------------------------
+    // Listing — transparent cursor pagination
+    // -------------------------------------------------------------------------
+    keys: async (prefix) => {
+      const kv2 = getKV();
+      const keys = await listAllKeys(kv2, prefix);
+      return keys.map((k) => k.name);
+    },
+    list: async (options) => {
+      const kv2 = getKV();
+      return await kv2.list({
+        prefix: options?.prefix,
+        limit: options?.limit ?? 1e3,
+        cursor: options?.cursor
+      });
+    },
+    clear: async (prefix) => {
+      const kv2 = getKV();
+      const keys = await listAllKeys(kv2, prefix);
+      await Promise.all(keys.map((k) => kv2.delete(k.name)));
+    },
+    // -------------------------------------------------------------------------
+    // CF-native: metadata (unstorage can't do this)
+    // -------------------------------------------------------------------------
+    getWithMetadata: async (key, options) => {
+      const kv2 = getKV();
+      const type = options?.type ?? "json";
+      const cacheTtl = options?.cacheTtl;
+      if (type === "json") {
+        const { value: raw, metadata: metadata2 } = await kv2.getWithMetadata(key, { type: "text", cacheTtl });
+        return { value: deserialize(raw), metadata: metadata2 };
+      }
+      const { value, metadata } = await kv2.getWithMetadata(key, { type, cacheTtl });
+      return { value, metadata };
+    },
+    // -------------------------------------------------------------------------
+    // Raw escape hatch
+    // -------------------------------------------------------------------------
+    raw: (bName) => {
+      return getKVBinding(bName || resolvedBinding, event);
+    }
+  };
+}
+export const useKV = createKV;
+export const kv = createKV();
+export const getKVStorage = getKVBinding;

package/dist/runtime/payments.d.ts

@@ -0,0 +1,2 @@
+export type * from "./app/composables/payments";
+export type { PaymentProvider, SubscriptionStatus, PaymentPlanConfig, PaymentsOptions, QarpeoCustomer, QarpeoSubscription, CreateCheckoutOptions, QarpeoWebhookEvent, } from "../types";

package/dist/runtime/queue.d.ts

@@ -0,0 +1,21 @@
+import type { CFEvent } from "./types/index";
+import type { QarpeoQueue, Queue } from "./types/queue";
+export type * from "./types/queue";
+/**
+ * Returns the raw Cloudflare Queue binding from the active environment.
+ *
+ * @param bindingName Optional Cloudflare Queue binding name (defaults to 'QUEUE')
+ * @param event Optional event context
+ */
+export declare function getQueueBinding<T = any>(bindingName?: string, event?: CFEvent): Queue<T>;
+/** Creates a typed Queue client for a specific binding and optional event. */
+export declare function createQueue<T = any>(bindingName?: string, event?: CFEvent): QarpeoQueue<T>;
+/**
+ * Access a typed Cloudflare Queue client.
+ *
+ * @param bindingName Optional Cloudflare Queue binding name (defaults to 'QUEUE')
+ * @param event Optional event context
+ */
+export declare const useQueue: <T = any>(bindingName?: string, event?: CFEvent) => QarpeoQueue<T>;
+/** Auto-imported `queue` instance for direct Cloudflare Queue operations. */
+export declare const queue: QarpeoQueue<any>;

package/dist/runtime/queue.mjs

@@ -0,0 +1,41 @@
+import { getCloudflareEnv, resolveRuntimeBinding } from "./bindings.mjs";
+export function getQueueBinding(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("queue", bindingName, "QUEUE");
+  const env = getCloudflareEnv(event);
+  const binding = env[resolvedBinding];
+  if (!binding) {
+    throw new Error(
+      `[qarpeo] Cloudflare Queue binding "${resolvedBinding}" was not found. Check your wrangler.json or QARPEO_QUEUE_BINDING environment variable.`
+    );
+  }
+  return binding;
+}
+export function createQueue(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("queue", bindingName, "QUEUE");
+  const getQ = () => getQueueBinding(resolvedBinding, event);
+  return {
+    send: (message, options) => {
+      return getQ().send(message, options);
+    },
+    sendBatch: (messages, options) => {
+      return getQ().sendBatch(messages, options);
+    },
+    raw: (bName) => {
+      return getQueueBinding(bName || resolvedBinding, event);
+    }
+  };
+}
+export const useQueue = createQueue;
+export const queue = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "raw") {
+      return (bindingName) => getQueueBinding(bindingName);
+    }
+    const instance = createQueue();
+    const val = instance[prop];
+    if (typeof val === "function") {
+      return val.bind(instance);
+    }
+    return val;
+  }
+});

package/dist/runtime/rag.d.ts

@@ -0,0 +1 @@
+export * from "./server/utils/rag";

package/dist/runtime/rag.mjs

@@ -0,0 +1 @@
+export * from "./server/utils/rag.mjs";

package/dist/runtime/ratelimit.d.ts

@@ -0,0 +1,21 @@
+import type { CFEvent } from "./types/index";
+import type { QarpeoRateLimit, RateLimiterBinding } from "./types/ratelimit";
+export type * from "./types/ratelimit";
+/**
+ * Returns the raw Cloudflare RateLimiter binding from the active environment.
+ *
+ * @param bindingName Optional Cloudflare RateLimiter binding name (defaults to 'RATE_LIMITER')
+ * @param event Optional event context
+ */
+export declare function getRateLimitBinding(bindingName?: string, event?: CFEvent): RateLimiterBinding;
+/** Creates a typed RateLimiter client for a specific binding and optional event. */
+export declare function createRateLimit(bindingName?: string, event?: CFEvent): QarpeoRateLimit;
+/**
+ * Access a typed Cloudflare RateLimiter client.
+ *
+ * @param bindingName Optional RateLimiter binding name (defaults to 'RATE_LIMITER')
+ * @param event Optional event context
+ */
+export declare const useRateLimit: (bindingName?: string, event?: CFEvent) => QarpeoRateLimit;
+/** Auto-imported `rateLimit` instance for direct Cloudflare RateLimiter operations. */
+export declare const rateLimit: QarpeoRateLimit;

package/dist/runtime/ratelimit.mjs

@@ -0,0 +1,38 @@
+import { getCloudflareEnv, resolveRuntimeBinding } from "./bindings.mjs";
+export function getRateLimitBinding(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("ratelimit", bindingName, "RATE_LIMITER");
+  const env = getCloudflareEnv(event);
+  const binding = env[resolvedBinding];
+  if (!binding) {
+    throw new Error(
+      `[qarpeo] Cloudflare RateLimiter binding "${resolvedBinding}" was not found. Check your wrangler.json or QARPEO_RATELIMIT_BINDING environment variable.`
+    );
+  }
+  return binding;
+}
+export function createRateLimit(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("ratelimit", bindingName, "RATE_LIMITER");
+  const getLimiter = () => getRateLimitBinding(resolvedBinding, event);
+  return {
+    limit: (options) => {
+      return getLimiter().limit(options);
+    },
+    raw: (bName) => {
+      return getRateLimitBinding(bName || resolvedBinding, event);
+    }
+  };
+}
+export const useRateLimit = createRateLimit;
+export const rateLimit = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "raw") {
+      return (bindingName) => getRateLimitBinding(bindingName);
+    }
+    const instance = createRateLimit();
+    const val = instance[prop];
+    if (typeof val === "function") {
+      return val.bind(instance);
+    }
+    return val;
+  }
+});

package/dist/runtime/realtime.d.ts

@@ -0,0 +1,6 @@
+export { QarpeoRoomDO } from "./server/durable-objects/room";
+export { useRealtime, usePresence, useRoomState } from "./app/composables/realtime";
+export { broadcastToRoom, getRoomPresence, getRoomHistory, getRoomState, setRoomState, patchRoomState, disconnectRoomUser, getRoomDurableObject, defineRealtimeHandler, } from "./server/utils/realtime";
+export type { RealtimeOptions, RealtimeUser, RealtimeMessage, RealtimePeer, RealtimeHandlerOptions, RealtimeHandlerRegistration, UsePresenceOptions, UsePresenceReturn, UseRoomStateReturn, } from "../types";
+export type { DurableObjectId, DurableObjectStub, DurableObjectNamespace, DurableObjectState, DurableObjectStorage, } from "./types";
+export type { UseRealtimeOptions, UseRealtimeReturn } from "./app/composables/realtime";

package/dist/runtime/realtime.mjs

@@ -0,0 +1,13 @@
+export { QarpeoRoomDO } from "./server/durable-objects/room.mjs";
+export { useRealtime, usePresence, useRoomState } from "./app/composables/realtime.mjs";
+export {
+  broadcastToRoom,
+  getRoomPresence,
+  getRoomHistory,
+  getRoomState,
+  setRoomState,
+  patchRoomState,
+  disconnectRoomUser,
+  getRoomDurableObject,
+  defineRealtimeHandler
+} from "./server/utils/realtime.mjs";