@lunora/bindings 1.0.0-alpha.11 → 1.0.0-alpha.13

package/dist/packem_shared/WindowExpression-BT_uA6g1.mjs

@@ -1,44 +0,0 @@
-import { Sql, lit } from './Sql-B3zq2YGx.mjs';
-
-const IDENTIFIER = /^[A-Z_][\w$]*$/i;
-const assertIdent = (name) => {
-  if (!IDENTIFIER.test(name)) {
-    throw new TypeError(`r2sql: invalid identifier ${JSON.stringify(name)} — expected a simple SQL name (letters, digits, underscore).`);
-  }
-  return name;
-};
-class WindowExpression extends Sql {
-  /** Alias the expression — `... AS alias` — for use in a `SELECT` list. */
-  as(alias) {
-    return new Sql(`${this.text} AS ${assertIdent(alias)}`);
-  }
-  /** `expr BETWEEN low AND high`. */
-  between(low, high) {
-    return new Sql(`${this.text} BETWEEN ${lit(low)} AND ${lit(high)}`);
-  }
-  /** `expr = value`. */
-  eq(value) {
-    return this.compare("=", value);
-  }
-  /** `expr > value`. */
-  gt(value) {
-    return this.compare(">", value);
-  }
-  /** `expr >= value`. */
-  gte(value) {
-    return this.compare(">=", value);
-  }
-  /** `expr < value`. */
-  lt(value) {
-    return this.compare("<", value);
-  }
-  /** `expr &lt;= value`. */
-  lte(value) {
-    return this.compare("<=", value);
-  }
-  compare(operator, value) {
-    return new Sql(`${this.text} ${operator} ${lit(value)}`);
-  }
-}
-
-export { WindowExpression as default };

package/dist/packem_shared/WindowFunction-DrnuZUF6.mjs

@@ -1,82 +0,0 @@
-import { renderOrderTerm } from './asc-DZbQCxh1.mjs';
-import { lit, toText } from './Sql-B3zq2YGx.mjs';
-import WindowExpression from './WindowExpression-BT_uA6g1.mjs';
-
-const toArray = (value) => {
-  if (value === void 0) {
-    return [];
-  }
-  return Array.isArray(value) ? value : [value];
-};
-const renderOver = (spec) => {
-  const clauses = [];
-  const partitions = toArray(spec.partitionBy).map((part) => toText(part));
-  if (partitions.length > 0) {
-    clauses.push(`PARTITION BY ${partitions.join(", ")}`);
-  }
-  const orders = toArray(spec.orderBy).map((order) => renderOrderTerm(order));
-  if (orders.length > 0) {
-    clauses.push(`ORDER BY ${orders.join(", ")}`);
-  }
-  if (spec.frame !== void 0 && spec.frame.length > 0) {
-    clauses.push(spec.frame);
-  }
-  return `OVER (${clauses.join(" ")})`;
-};
-const offsetArguments = (column, offset, fallback) => {
-  const parts = [toText(column)];
-  if (offset !== void 0) {
-    parts.push(lit(offset));
-  }
-  if (fallback !== void 0) {
-    parts.push(lit(fallback));
-  }
-  return parts.join(", ");
-};
-class WindowFunction {
-  callText;
-  constructor(callText) {
-    this.callText = callText;
-  }
-  /** Attach the window frame, yielding a {@link WindowExpression}. */
-  over(spec = {}) {
-    return new WindowExpression(`${this.callText} ${renderOver(spec)}`);
-  }
-}
-const windowFunction = (callText) => new WindowFunction(callText);
-const fn = {
-  /** `AVG(column) OVER (...)`. */
-  avg: (column) => windowFunction(`AVG(${toText(column)})`),
-  /** `COUNT(column) OVER (...)` — omit the column for `COUNT(*)`. */
-  count: (column) => windowFunction(`COUNT(${column === void 0 ? "*" : toText(column)})`),
-  /** `CUME_DIST() OVER (...)`. */
-  cumeDist: () => windowFunction("CUME_DIST()"),
-  /** `DENSE_RANK() OVER (...)`. */
-  denseRank: () => windowFunction("DENSE_RANK()"),
-  /** `FIRST_VALUE(column) OVER (...)`. */
-  firstValue: (column) => windowFunction(`FIRST_VALUE(${toText(column)})`),
-  /** `LAG(column[, offset[, default]]) OVER (...)`. */
-  lag: (column, offset, fallback) => windowFunction(`LAG(${offsetArguments(column, offset, fallback)})`),
-  /** `LAST_VALUE(column) OVER (...)`. */
-  lastValue: (column) => windowFunction(`LAST_VALUE(${toText(column)})`),
-  /** `LEAD(column[, offset[, default]]) OVER (...)`. */
-  lead: (column, offset, fallback) => windowFunction(`LEAD(${offsetArguments(column, offset, fallback)})`),
-  /** `MAX(column) OVER (...)`. */
-  max: (column) => windowFunction(`MAX(${toText(column)})`),
-  /** `MIN(column) OVER (...)`. */
-  min: (column) => windowFunction(`MIN(${toText(column)})`),
-  /** `NTH_VALUE(column, n) OVER (...)`. */
-  nthValue: (column, n) => windowFunction(`NTH_VALUE(${toText(column)}, ${lit(n)})`),
-  /** `NTILE(buckets) OVER (...)`. */
-  ntile: (buckets) => windowFunction(`NTILE(${lit(buckets)})`),
-  /** `PERCENT_RANK() OVER (...)`. */
-  percentRank: () => windowFunction("PERCENT_RANK()"),
-  /** `RANK() OVER (...)`. */
-  rank: () => windowFunction("RANK()"),
-  /** `ROW_NUMBER() OVER (...)`. */
-  rowNumber: () => windowFunction("ROW_NUMBER()"),
-  /** `SUM(column) OVER (...)`. */
-  sum: (column) => windowFunction(`SUM(${toText(column)})`)
-};
-
-export { WindowFunction, fn };

package/dist/packem_shared/asc-DZbQCxh1.mjs

@@ -1,16 +0,0 @@
-import { Sql, toText } from './Sql-B3zq2YGx.mjs';
-
-const asc = (expr) => {
-  return { dir: "ASC", expr };
-};
-const desc = (expr) => {
-  return { dir: "DESC", expr };
-};
-const renderOrderTerm = (term) => {
-  if (typeof term === "string" || term instanceof Sql) {
-    return toText(term);
-  }
-  return `${toText(term.expr)} ${term.dir}`;
-};
-
-export { asc, desc, renderOrderTerm };

package/dist/packem_shared/buildImageDeliveryUrl-qZ7XbqTL.mjs

@@ -1,35 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const ABSOLUTE_URL_RE = /^[a-z][a-z\d+\-.]*:\/\//i;
-const FORBIDDEN_VALUE_CHARS = [",", "=", "#", "?", "/"];
-const stripTrailingSlash = (value) => value.endsWith("/") ? value.slice(0, -1) : value;
-const stripLeadingSlash = (value) => value.startsWith("/") ? value.slice(1) : value;
-const serializeTransform = (transform) => Object.entries(transform).filter(([, value]) => value !== void 0 && (typeof value === "string" || typeof value === "number")).map(([key, value]) => {
-  const serialized = String(value);
-  const offendingChar = FORBIDDEN_VALUE_CHARS.find((char) => serialized.includes(char));
-  if (offendingChar !== void 0) {
-    throw new LunoraError(
-      "INTERNAL",
-      `@lunora/bindings/images: transform option \`${key}\` value \`${serialized}\` contains a \`${offendingChar}\`, which the /cdn-cgi/image/ option path cannot represent (\`,\`/\`=\` are the option/key-value separators; \`#\`/\`?\`/\`/\` are URL-structural). Percent-encode the value — for colors use \`%23RRGGBB\`, not \`#RRGGBB\` or \`rgb(r,g,b)\`.`
-    );
-  }
-  return `${key}=${serialized}`;
-}).join(",");
-const encodeKey = (key) => key.split("/").map((segment) => encodeURIComponent(segment)).join("/");
-const buildImageDeliveryUrl = (options) => {
-  const base = stripTrailingSlash(options.baseUrl);
-  if (options.imageId !== void 0) {
-    const variant = options.variant ?? "public";
-    return `${base}/${encodeURIComponent(options.imageId)}/${encodeURIComponent(variant)}`;
-  }
-  if (options.key === void 0) {
-    throw new LunoraError("INTERNAL", "@lunora/bindings/images: buildImageDeliveryUrl requires either `imageId` or `key`");
-  }
-  const optionString = options.transform === void 0 ? "" : serializeTransform(options.transform);
-  const isAbsolute = ABSOLUTE_URL_RE.test(options.key);
-  const source = isAbsolute ? options.key : `/${encodeKey(stripLeadingSlash(options.key))}`;
-  const prefix = optionString === "" ? "/cdn-cgi/image" : `/cdn-cgi/image/${optionString}`;
-  return `${base}${prefix}${source.startsWith("/") ? source : `/${source}`}`;
-};
-
-export { buildImageDeliveryUrl };

package/dist/packem_shared/buildSignedImageUrl-DNUFfyGP.mjs

@@ -1,130 +0,0 @@
-const evictOldestEntry = (map, capacity) => {
-  if (map.size < capacity) {
-    return;
-  }
-  const oldest = map.keys().next().value;
-  if (oldest !== void 0) {
-    map.delete(oldest);
-  }
-};
-
-const textEncoder = new TextEncoder();
-const MAX_SIGNED_URL_TTL_SECONDS = 7 * 24 * 60 * 60;
-const SCHEME_PREFIX_RE = /^[a-z][a-z0-9+\-.]*:\/\//i;
-const toBase64Url = (bytes) => {
-  const binary = String.fromCodePoint(...bytes);
-  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
-};
-const fromBase64Url = (input) => {
-  const padded = input.replaceAll("-", "+").replaceAll("_", "/") + "===".slice((input.length + 3) % 4);
-  const binary = atob(padded);
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0; index < binary.length; index += 1) {
-    bytes[index] = binary.codePointAt(index) ?? 0;
-  }
-  return bytes;
-};
-const KEY_CACHE_MAX = 64;
-const keyCache = /* @__PURE__ */ new Map();
-const importHmacKey = async (secret) => {
-  const cached = keyCache.get(secret);
-  if (cached) {
-    return cached;
-  }
-  evictOldestEntry(keyCache, KEY_CACHE_MAX);
-  const keyPromise = crypto.subtle.importKey("raw", textEncoder.encode(secret), { hash: "SHA-256", name: "HMAC" }, false, ["sign", "verify"]);
-  keyCache.set(secret, keyPromise);
-  return keyPromise;
-};
-const extractHost = (input) => {
-  try {
-    return new URL(input).host;
-  } catch {
-    const noScheme = input.replace(SCHEME_PREFIX_RE, "");
-    return noScheme.split("/")[0] ?? "";
-  }
-};
-const signCanonical = async (secret, canonical) => {
-  const cryptoKey = await importHmacKey(secret);
-  const signature = await crypto.subtle.sign("HMAC", cryptoKey, textEncoder.encode(canonical));
-  return toBase64Url(new Uint8Array(signature));
-};
-const verifyCanonical = async (secret, canonical, sigBytes) => {
-  const cryptoKey = await importHmacKey(secret);
-  return crypto.subtle.verify("HMAC", cryptoKey, sigBytes, textEncoder.encode(canonical));
-};
-
-const LEADING_SLASH_RE = /^\//;
-const serializeTransform = (transform) => {
-  if (transform === void 0) {
-    return "";
-  }
-  return Object.entries(transform).filter(([, value]) => value !== void 0).toSorted(([a], [b]) => (a > b ? 1 : 0) - (a < b ? 1 : 0)).map(([key, value]) => `${key}=${typeof value === "object" ? JSON.stringify(value) : String(value)}`).join("&");
-};
-const canonicalize = (host, key, exp, transform) => `${host.toLowerCase()}
-${key}
-${String(exp)}
-${transform}`;
-const encodeKey = (key) => key.split("/").map((segment) => encodeURIComponent(segment)).join("/");
-const buildSignedImageUrl = async (options) => {
-  const expiresInSeconds = options.expiresInSeconds ?? 60 * 60;
-  if (!Number.isFinite(expiresInSeconds) || expiresInSeconds <= 0) {
-    throw new TypeError("@lunora/bindings/images: expiresInSeconds must be a positive finite number");
-  }
-  if (expiresInSeconds > MAX_SIGNED_URL_TTL_SECONDS) {
-    throw new TypeError(`@lunora/bindings/images: expiresInSeconds must not exceed ${String(MAX_SIGNED_URL_TTL_SECONDS)} (7 days)`);
-  }
-  let basePath = "";
-  try {
-    basePath = new URL(options.baseUrl).pathname;
-  } catch {
-  }
-  if (basePath !== "" && basePath !== "/") {
-    throw new TypeError(
-      `@lunora/bindings/images: baseUrl must not carry a path ("${basePath}") — the key is verified from the full URL pathname, so a subpath base would make every signed URL fail verification`
-    );
-  }
-  const exp = Math.floor(Date.now() / 1e3) + expiresInSeconds;
-  const host = extractHost(options.baseUrl);
-  const transform = serializeTransform(options.transform);
-  const normalizedKey = options.key.replace(LEADING_SLASH_RE, "");
-  const sig = await signCanonical(options.secret, canonicalize(host, normalizedKey, exp, transform));
-  const base = options.baseUrl.endsWith("/") ? options.baseUrl.slice(0, -1) : options.baseUrl;
-  const safeKey = encodeKey(normalizedKey);
-  const tParameter = transform === "" ? "" : `&t=${encodeURIComponent(transform)}`;
-  return `${base}/${safeKey}?exp=${String(exp)}&sig=${sig}${tParameter}`;
-};
-const verifySignedImageUrl = async (input, secret, options) => {
-  let url;
-  try {
-    url = input instanceof URL ? input : new URL(input);
-  } catch {
-    return { reason: "malformed", valid: false };
-  }
-  const expRaw = url.searchParams.get("exp");
-  const exp = expRaw === null ? Number.NaN : Number(expRaw);
-  const sig = url.searchParams.get("sig");
-  const transform = url.searchParams.get("t") ?? "";
-  if (!sig || !Number.isInteger(exp)) {
-    return { reason: "malformed", valid: false };
-  }
-  if (exp < Math.floor(Date.now() / 1e3)) {
-    return { reason: "expired", valid: false };
-  }
-  let key;
-  let sigBytes;
-  try {
-    key = url.pathname.replace(LEADING_SLASH_RE, "").split("/").map((segment) => decodeURIComponent(segment)).join("/");
-    sigBytes = fromBase64Url(sig);
-  } catch {
-    return { reason: "malformed", valid: false };
-  }
-  const host = options?.expectedHost === void 0 ? url.host : extractHost(options.expectedHost);
-  const valid = await verifyCanonical(secret, canonicalize(host, key, exp, transform), sigBytes);
-  if (!valid) {
-    return { reason: "bad_signature", valid: false };
-  }
-  return { key, transform: transform === "" ? void 0 : transform, valid: true };
-};
-
-export { buildSignedImageUrl, verifySignedImageUrl };

package/dist/packem_shared/concurrent-CkCEVwqP.mjs

@@ -1,39 +0,0 @@
-const UPSERT_EMBED_CONCURRENCY = 8;
-const concurrentMap = async (items, limit, function_) => {
-  if (items.length === 0) {
-    return [];
-  }
-  const effectiveLimit = Math.max(1, Math.min(limit, items.length));
-  const results = Array.from({ length: items.length });
-  let cursor = 0;
-  let failed = false;
-  let firstError;
-  const workers = Array.from({ length: effectiveLimit }, async () => {
-    for (; ; ) {
-      if (failed) {
-        return;
-      }
-      const index = cursor;
-      cursor += 1;
-      if (index >= items.length) {
-        return;
-      }
-      try {
-        results[index] = await function_(items[index], index);
-      } catch (error) {
-        if (!failed) {
-          failed = true;
-          firstError = error;
-        }
-        return;
-      }
-    }
-  });
-  await Promise.all(workers);
-  if (failed) {
-    throw firstError;
-  }
-  return results;
-};
-
-export { UPSERT_EMBED_CONCURRENCY as U, concurrentMap as c };

package/dist/packem_shared/createAnalytics-CEEI69o9.mjs

@@ -1,57 +0,0 @@
-const MAX_BLOBS = 20;
-const MAX_DOUBLES = 20;
-const MAX_INDEXES = 1;
-const MAX_BLOB_BYTES = 16 * 1024;
-const MAX_INDEX_BYTES = 96;
-const TEXT_ENCODER = new TextEncoder();
-const byteLengthOf = (value) => {
-  if (value === null) {
-    return 0;
-  }
-  if (typeof value === "string") {
-    return TEXT_ENCODER.encode(value).length;
-  }
-  return value.byteLength;
-};
-const assertWithin = (kind, length, max) => {
-  if (length > max) {
-    throw new RangeError(`@lunora/bindings/analytics: a data point may carry at most ${String(max)} ${kind} (got ${String(length)}).`);
-  }
-};
-const assertByteBudget = (kind, bytes, max) => {
-  if (bytes > max) {
-    throw new RangeError(`@lunora/bindings/analytics: a data point's ${kind} may total at most ${String(max)} bytes (got ${String(bytes)}).`);
-  }
-};
-const createAnalytics = (binding) => {
-  const writeDataPoint = (event) => {
-    assertWithin("blobs", event.blobs?.length ?? 0, MAX_BLOBS);
-    assertWithin("doubles", event.doubles?.length ?? 0, MAX_DOUBLES);
-    assertWithin("indexes", event.indexes?.length ?? 0, MAX_INDEXES);
-    const blobBytes = (event.blobs ?? []).reduce((total, blob) => total + byteLengthOf(blob), 0);
-    assertByteBudget("blobs", blobBytes, MAX_BLOB_BYTES);
-    for (const index of event.indexes ?? []) {
-      assertByteBudget("index", byteLengthOf(index), MAX_INDEX_BYTES);
-    }
-    binding.writeDataPoint(event);
-  };
-  const track = (name, event = {}) => {
-    const dimensionEntries = Object.entries(event.dimensions ?? {});
-    const metricEntries = Object.entries(event.metrics ?? {});
-    const blobs = [name, ...dimensionEntries.map(([, value]) => value)];
-    const doubles = metricEntries.map(([, value]) => value);
-    const indexes = event.index === void 0 ? [] : [event.index];
-    writeDataPoint({ blobs, doubles, indexes });
-    const dimensions = dimensionEntries.map(([field], offset) => {
-      return { column: `blob${String(offset + 2)}`, field };
-    });
-    const metrics = metricEntries.map(([field], offset) => {
-      return { column: `double${String(offset + 1)}`, field };
-    });
-    const index = event.index === void 0 ? null : { column: "index1", field: "index" };
-    return { dimensions, index, metrics, name };
-  };
-  return { track, writeDataPoint };
-};
-
-export { createAnalytics };

package/dist/packem_shared/createContextVectors-DwZtnPeC.mjs

@@ -1,140 +0,0 @@
-import { c as concurrentMap, U as UPSERT_EMBED_CONCURRENCY } from './concurrent-CkCEVwqP.mjs';
-
-const createContextVectors = (lunora) => {
-  const upsert = async (indexName, input) => {
-    await lunora.upsert(indexName, {
-      embed: input.embed,
-      id: input.id,
-      input: input.input,
-      metadata: input.metadata,
-      namespace: input.namespace
-    });
-  };
-  return {
-    deleteByIds: async (indexName, ids) => {
-      await lunora.deleteByIds(indexName, ids);
-    },
-    getByIds: async (indexName, ids) => {
-      const records = await lunora.getByIds(indexName, ids);
-      return records.map((record) => {
-        return { id: record.id, metadata: record.metadata, values: record.values };
-      });
-    },
-    query: async (indexName, input) => {
-      const result = await lunora.query(indexName, {
-        embed: input.embed,
-        filter: input.filter,
-        input: input.input,
-        namespace: input.namespace,
-        // Default to "indexed" rather than "all": returning every
-        // metadata field by default leaks whatever was stored on the
-        // vector (potentially cross-tenant if namespaces aren't wired).
-        // Callers that need full metadata opt in explicitly via input.
-        returnMetadata: input.returnMetadata ?? "indexed",
-        topK: input.topK,
-        vector: input.vector
-      });
-      return {
-        count: result.count,
-        matches: result.matches.map((match) => {
-          return { id: match.id, metadata: match.metadata, score: match.score };
-        })
-      };
-    },
-    upsert,
-    upsertNow: upsert
-  };
-};
-const sharedNamespaceWarned = /* @__PURE__ */ new Set();
-const warnSharedNamespace = (indexName) => {
-  if (sharedNamespaceWarned.has(indexName)) {
-    return;
-  }
-  sharedNamespaceWarned.add(indexName);
-  console.warn(
-    `[@lunora/bindings/vectors] index "${indexName}" syncs vectors without a namespace — in a
-multi-tenant/sharded app this exposes one tenant's vectors (and any captured
-metadata) to every other tenant, since Vectorize indexes are account-global.
-Pass \`namespace\` (the shard/tenant key) on both write and query — query-side
-namespace filtering is mandatory for multi-tenant apps. Single-tenant apps that
-legitimately have no tenant key suppress this via { allowSharedNamespace: true }.`
-  );
-};
-const pickMetadata = (row, fields) => {
-  const result = {};
-  for (const field of fields) {
-    if (field in row) {
-      result[field] = row[field];
-    }
-  }
-  return result;
-};
-const createVectorSyncHook = (options) => {
-  const { allowSharedNamespace, namespace, schema, vectors } = options;
-  return async (event) => {
-    const tableDefinition = schema.tables[event.table];
-    const inlineIndexes = tableDefinition?.vectorIndexes ?? [];
-    const standaloneIndexes = Object.entries(schema.vectorIndexes).filter(([, definition]) => definition.table === event.table);
-    if (inlineIndexes.length === 0 && standaloneIndexes.length === 0) {
-      return;
-    }
-    const allIndexNames = [...inlineIndexes.map((index) => index.name), ...standaloneIndexes.map(([name]) => name)];
-    if (event.op === "delete") {
-      await Promise.all(allIndexNames.map((name) => vectors.deleteByIds(name, [event.id])));
-      return;
-    }
-    const row = event.doc;
-    if (!row) {
-      return;
-    }
-    const inlineWithValue = inlineIndexes.map((index) => {
-      return { index, value: row[index.field] };
-    });
-    const inlineToUpsert = inlineWithValue.filter((entry) => entry.value !== void 0 && entry.value !== null);
-    const inlineToClear = inlineWithValue.filter((entry) => entry.value === void 0 || entry.value === null);
-    for (const { index, value } of inlineToUpsert) {
-      if (typeof value !== "string") {
-        throw new TypeError(
-          `@lunora/bindings/vectors: inline index "${index.name}" expects a string source at "${index.field}" on table "${event.table}" (got ${typeof value}); use a standalone defineVectorIndex with a select() to derive text from non-string columns`
-        );
-      }
-    }
-    const operations = [
-      ...inlineToClear.map((entry) => async () => {
-        await vectors.deleteByIds(entry.index.name, [event.id]);
-      }),
-      ...inlineToUpsert.map((entry) => async () => {
-        if (!allowSharedNamespace && namespace === void 0) {
-          warnSharedNamespace(entry.index.name);
-        }
-        await vectors.upsert(entry.index.name, {
-          embed: entry.index.embed,
-          id: event.id,
-          input: entry.value,
-          metadata: entry.index.metadata ? pickMetadata(row, entry.index.metadata) : void 0,
-          namespace
-        });
-      }),
-      ...standaloneIndexes.map(([name, definition]) => async () => {
-        if (!allowSharedNamespace && namespace === void 0) {
-          warnSharedNamespace(name);
-        }
-        await vectors.upsert(name, {
-          embed: definition.embed,
-          id: event.id,
-          input: definition.select(row),
-          metadata: definition.metadata?.(row),
-          namespace
-        });
-      })
-    ];
-    try {
-      await concurrentMap(operations, UPSERT_EMBED_CONCURRENCY, async (operation) => operation());
-    } catch (error) {
-      await Promise.allSettled(allIndexNames.map((name) => vectors.deleteByIds(name, [event.id])));
-      throw error;
-    }
-  };
-};
-
-export { createContextVectors, createVectorSyncHook };

package/dist/packem_shared/createImages-BzRnsz3H.mjs

@@ -1,85 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const ALLOWED_OUTPUT_FORMATS = /* @__PURE__ */ new Set(["image/avif", "image/gif", "image/jpeg", "image/png", "image/webp"]);
-const DEFAULT_MAX_DIMENSION = 1e4;
-const DEFAULT_OUTPUT_FORMAT = "image/webp";
-const isR2ObjectBody = (input) => {
-  if (typeof input !== "object") {
-    return false;
-  }
-  const object = input;
-  return "body" in object && !(input instanceof ArrayBuffer) && !(input instanceof Uint8Array);
-};
-const toStream = (input) => {
-  if (input instanceof ReadableStream) {
-    return input;
-  }
-  if (isR2ObjectBody(input)) {
-    if (input.body === null) {
-      throw new LunoraError("INTERNAL", "@lunora/bindings/images: R2 object body is null (object missing or already consumed)");
-    }
-    return input.body;
-  }
-  if (input instanceof Blob) {
-    return input.stream();
-  }
-  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
-  return new ReadableStream({
-    start(controller) {
-      controller.enqueue(bytes);
-      controller.close();
-    }
-  });
-};
-const sanitizeTransform = (transform, maxDimension) => {
-  if (transform === void 0) {
-    return {};
-  }
-  const clampDimension = (value) => {
-    if (!Number.isFinite(value) || value <= 0) {
-      throw new TypeError("@lunora/bindings/images: width/height must be a positive finite number");
-    }
-    return Math.min(Math.floor(value), maxDimension);
-  };
-  const rest = { ...transform };
-  delete rest.draw;
-  return {
-    ...rest,
-    ...transform.width === void 0 ? {} : { width: clampDimension(transform.width) },
-    ...transform.height === void 0 ? {} : { height: clampDimension(transform.height) }
-  };
-};
-const splitOverlay = (overlay) => {
-  const { image, transform, ...drawOptions } = overlay;
-  return { drawOptions, image, transform };
-};
-const resolveOutput = (output) => {
-  const format = output?.format ?? DEFAULT_OUTPUT_FORMAT;
-  if (!ALLOWED_OUTPUT_FORMATS.has(format)) {
-    throw new LunoraError(
-      "INTERNAL",
-      `@lunora/bindings/images: unsupported output format "${format}" (allowed: ${[...ALLOWED_OUTPUT_FORMATS].join(", ")})`
-    );
-  }
-  return { ...output, format };
-};
-const createImages = (options) => {
-  const { binding } = options;
-  const maxDimension = options.maxDimension ?? DEFAULT_MAX_DIMENSION;
-  return {
-    info: async (input) => binding.info(toStream(input)),
-    transform: async (input, transform, output, overlays) => {
-      const safeTransform = sanitizeTransform(transform, maxDimension);
-      const outputOptions = resolveOutput(output);
-      let transformer = binding.input(toStream(input)).transform(safeTransform);
-      for (const overlay of overlays ?? []) {
-        const { drawOptions, image, transform: overlayTransform } = splitOverlay(overlay);
-        const overlayImage = overlayTransform === void 0 ? toStream(image) : binding.input(toStream(image)).transform(sanitizeTransform(overlayTransform, maxDimension));
-        transformer = transformer.draw(overlayImage, drawOptions);
-      }
-      return transformer.output(outputOptions);
-    }
-  };
-};
-
-export { createImages };