@lunora/bindings 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/packem_shared/createContextVectors-BSizpmu5.mjs

@@ -1,140 +0,0 @@
-import { c as concurrentMap, U as UPSERT_EMBED_CONCURRENCY } from './concurrent-Dj5sOibv.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-CJrvqX0u.mjs

@@ -1,80 +0,0 @@
-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 Error("@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 Error("@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 Error(`@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 };

package/dist/packem_shared/createKv-DTiSt216.mjs

@@ -1,141 +0,0 @@
-const MAX_KEY_LENGTH = 512;
-const MAX_LIST_LIMIT = 1e3;
-const validateKey = (key) => {
-  if (typeof key !== "string" || key.length === 0) {
-    throw new Error("@lunora/bindings/kv: key must be a non-empty string");
-  }
-  if (key.length > MAX_KEY_LENGTH) {
-    throw new Error(`@lunora/bindings/kv: key exceeds ${String(MAX_KEY_LENGTH)}-byte limit`);
-  }
-  if (key.includes("\0")) {
-    throw new Error("@lunora/bindings/kv: key contains NUL byte");
-  }
-  const segments = key.split("/");
-  for (const segment of segments) {
-    if (segment === "." || segment === "..") {
-      throw new Error("@lunora/bindings/kv: key contains a `.`/`..` path component");
-    }
-  }
-};
-const validatePrefix = (prefix) => {
-  if (prefix.length === 0) {
-    return;
-  }
-  if (prefix.length > MAX_KEY_LENGTH) {
-    throw new Error(`@lunora/bindings/kv: prefix exceeds ${String(MAX_KEY_LENGTH)}-byte limit`);
-  }
-  if (prefix.includes("\0")) {
-    throw new Error("@lunora/bindings/kv: prefix contains NUL byte");
-  }
-  const segments = prefix.split("/");
-  for (const segment of segments) {
-    if (segment === "." || segment === "..") {
-      throw new Error("@lunora/bindings/kv: prefix contains a `.`/`..` path component");
-    }
-  }
-};
-const scopeKey = (prefix, key) => {
-  validateKey(prefix);
-  validateKey(key);
-  const trimmedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-  const composed = `${trimmedPrefix}/${key}`;
-  if (composed.length > MAX_KEY_LENGTH) {
-    throw new Error(`@lunora/bindings/kv: scoped key exceeds ${String(MAX_KEY_LENGTH)}-byte limit`);
-  }
-  return composed;
-};
-const toPutOptions = (options) => {
-  const out = {};
-  if (options.expiration !== void 0 && options.expirationTtl !== void 0) {
-    throw new Error("@lunora/bindings/kv: `expiration` and `expirationTtl` are mutually exclusive");
-  }
-  if (options.expiration !== void 0) {
-    out.expiration = options.expiration;
-  }
-  if (options.expirationTtl !== void 0) {
-    out.expirationTtl = options.expirationTtl;
-  }
-  if (options.metadata !== void 0) {
-    out.metadata = options.metadata;
-  }
-  return Object.keys(out).length > 0 ? out : void 0;
-};
-const createKv = (options) => {
-  if (!options.namespace) {
-    throw new Error("@lunora/bindings/kv: `namespace` is required");
-  }
-  const { keyPrefix, namespace } = options;
-  if (keyPrefix !== void 0) {
-    validateKey(keyPrefix);
-  }
-  const resolve = (key) => {
-    if (keyPrefix === void 0) {
-      validateKey(key);
-      return key;
-    }
-    return scopeKey(keyPrefix, key);
-  };
-  const stripPrefix = (name) => {
-    if (keyPrefix === void 0) {
-      return name;
-    }
-    const trimmed = keyPrefix.endsWith("/") ? keyPrefix : `${keyPrefix}/`;
-    return name.startsWith(trimmed) ? name.slice(trimmed.length) : name;
-  };
-  const get = async (key, getOptions = {}) => {
-    const value = await namespace.get(resolve(key), { cacheTtl: getOptions.cacheTtl, type: "json" });
-    return value ?? null;
-  };
-  const getRaw = async (key, getOptions = {}) => {
-    const value = await namespace.get(resolve(key), { cacheTtl: getOptions.cacheTtl, type: getOptions.type ?? "text" });
-    return value ?? null;
-  };
-  const getWithMetadata = async (key, getOptions = {}) => {
-    const result = await namespace.getWithMetadata(resolve(key), { cacheTtl: getOptions.cacheTtl, type: "json" });
-    return { metadata: result.metadata ?? null, value: result.value ?? null };
-  };
-  const put = async (key, value, putOptions = {}) => {
-    const body = putOptions.raw ? value : JSON.stringify(value);
-    await namespace.put(resolve(key), body, toPutOptions(putOptions));
-  };
-  const deleteKey = async (key) => {
-    await namespace.delete(resolve(key));
-  };
-  const list = async (listOptions = {}) => {
-    if (listOptions.limit !== void 0 && (!Number.isInteger(listOptions.limit) || listOptions.limit <= 0)) {
-      throw new Error("@lunora/bindings/kv: `limit` must be a positive integer");
-    }
-    let { prefix } = listOptions;
-    if (prefix !== void 0) {
-      validatePrefix(prefix);
-    }
-    if (keyPrefix !== void 0) {
-      const base = keyPrefix.endsWith("/") ? keyPrefix : `${keyPrefix}/`;
-      prefix = listOptions.prefix === void 0 ? base : `${base}${listOptions.prefix}`;
-      validatePrefix(prefix);
-    }
-    const limit = listOptions.limit === void 0 ? void 0 : Math.min(listOptions.limit, MAX_LIST_LIMIT);
-    const result = await namespace.list({ cursor: listOptions.cursor, limit, prefix });
-    const keys = result.keys.map((entry) => {
-      return {
-        ...entry,
-        name: stripPrefix(entry.name)
-      };
-    });
-    return {
-      cursor: result.list_complete ? void 0 : result.cursor,
-      keys,
-      listComplete: result.list_complete
-    };
-  };
-  return {
-    delete: deleteKey,
-    get,
-    getRaw,
-    getWithMetadata,
-    list,
-    put
-  };
-};
-
-export { createKv, scopeKey };

package/dist/packem_shared/createPipelines-CfyJ6VGu.mjs

@@ -1,10 +0,0 @@
-const createPipelines = (options) => {
-  const { binding } = options;
-  return {
-    send: async (records) => {
-      await binding.send(Array.isArray(records) ? records : [records]);
-    }
-  };
-};
-
-export { createPipelines };

package/dist/packem_shared/createVectorAdminIntrospector-BJUOM6VW.mjs

@@ -1,51 +0,0 @@
-const MAX_TOP_K = 20;
-const DEFAULT_TOP_K = 10;
-const createVectorAdminIntrospector = (options) => {
-  const { embedders, indexes, registry } = options;
-  const listIndexes = async () => Promise.all(
-    registry.map(async (entry) => {
-      const binding = indexes[entry.name];
-      if (binding?.describe === void 0) {
-        return { ...entry };
-      }
-      try {
-        const details = await binding.describe();
-        return {
-          ...entry,
-          dimensions: entry.dimensions ?? details.dimensions,
-          processedUpToMutation: details.processedUpToMutation,
-          vectorsCount: details.vectorsCount
-        };
-      } catch {
-        return { ...entry };
-      }
-    })
-  );
-  const hasEmbedders = embedders !== void 0 && Object.keys(embedders).length > 0;
-  if (!hasEmbedders) {
-    return { listIndexes };
-  }
-  const queryIndex = async ({ name, text, topK }) => {
-    const binding = indexes[name];
-    if (binding === void 0) {
-      throw new Error(`@lunora/bindings/vectors: no Vectorize binding registered for index "${name}"`);
-    }
-    const embed = embedders[name];
-    if (embed === void 0) {
-      throw new Error(`@lunora/bindings/vectors: no embedder registered for index "${name}" — it lists read-only`);
-    }
-    const vector = await embed(text);
-    const result = await binding.query(vector, {
-      returnMetadata: "all",
-      topK: Math.min(topK ?? DEFAULT_TOP_K, MAX_TOP_K)
-    });
-    return {
-      matches: result.matches.map((match) => {
-        return { id: match.id, metadata: match.metadata, score: match.score };
-      })
-    };
-  };
-  return { listIndexes, queryIndex };
-};
-
-export { createVectorAdminIntrospector };

package/dist/packem_shared/createVectors-LSpGoKCd.mjs

@@ -1,91 +0,0 @@
-import { c as concurrentMap, U as UPSERT_EMBED_CONCURRENCY } from './concurrent-Dj5sOibv.mjs';
-
-const resolveIndex = (indexes, name) => {
-  const index = indexes[name];
-  if (!index) {
-    throw new Error(`@lunora/bindings/vectors: no index registered for "${name}". Known indexes: ${Object.keys(indexes).join(", ") || "(none)"}`);
-  }
-  return index;
-};
-const toVector = async (input) => {
-  const values = await input.embed(input.input);
-  return {
-    id: input.id,
-    metadata: input.metadata,
-    namespace: input.namespace,
-    values
-  };
-};
-const MAX_TOP_K = 100;
-const MAX_TOP_K_WITH_VALUES = 20;
-const MAX_ID_BATCH = 1e3;
-const MAX_UPSERT_BATCH = 1e3;
-const createVectors = (options) => {
-  if (Object.keys(options.indexes).length === 0) {
-    throw new Error("@lunora/bindings/vectors: at least one index binding is required");
-  }
-  const upsert = async (indexName, input) => {
-    const index = resolveIndex(options.indexes, indexName);
-    const vector = await toVector(input);
-    return index.upsert([vector]);
-  };
-  const upsertMany = async (indexName, inputs) => {
-    const index = resolveIndex(options.indexes, indexName);
-    if (inputs.length > MAX_UPSERT_BATCH) {
-      throw new RangeError(
-        `@lunora/bindings/vectors: upsertMany batch exceeds ${String(MAX_UPSERT_BATCH)} (got ${String(inputs.length)}) — split across calls`
-      );
-    }
-    const vectors = await concurrentMap(inputs, UPSERT_EMBED_CONCURRENCY, toVector);
-    return index.upsert(vectors);
-  };
-  const query = async (indexName, input) => {
-    const index = resolveIndex(options.indexes, indexName);
-    const wantsHeavyPayload = input.returnValues === true || input.returnMetadata === "all";
-    const topKCeiling = wantsHeavyPayload ? MAX_TOP_K_WITH_VALUES : MAX_TOP_K;
-    if (input.topK !== void 0 && (!Number.isInteger(input.topK) || input.topK < 1 || input.topK > topKCeiling)) {
-      const reason = wantsHeavyPayload ? ' (lowered to 20 because returnValues/returnMetadata:"all" is set)' : "";
-      throw new RangeError(`@lunora/bindings/vectors: topK must be an integer in [1, ${String(topKCeiling)}]${reason} (got ${String(input.topK)})`);
-    }
-    let values;
-    if (input.vector && input.vector.length > 0) {
-      values = input.vector;
-    } else {
-      if (!input.embed || input.input === void 0) {
-        throw new Error("@lunora/bindings/vectors: query requires either `vector` or both `input` and `embed`");
-      }
-      values = await input.embed(input.input);
-    }
-    return index.query(values, {
-      filter: input.filter,
-      namespace: input.namespace,
-      returnMetadata: input.returnMetadata,
-      returnValues: input.returnValues,
-      topK: input.topK
-    });
-  };
-  const getByIds = async (indexName, ids) => {
-    const index = resolveIndex(options.indexes, indexName);
-    if (ids.length > MAX_ID_BATCH) {
-      throw new RangeError(`@lunora/bindings/vectors: getByIds accepts at most ${String(MAX_ID_BATCH)} ids (got ${String(ids.length)})`);
-    }
-    return index.getByIds(ids);
-  };
-  const deleteByIds = async (indexName, ids) => {
-    const index = resolveIndex(options.indexes, indexName);
-    if (ids.length > MAX_ID_BATCH) {
-      throw new RangeError(`@lunora/bindings/vectors: deleteByIds accepts at most ${String(MAX_ID_BATCH)} ids (got ${String(ids.length)})`);
-    }
-    return index.deleteByIds(ids);
-  };
-  const describe = async (indexName) => {
-    const index = resolveIndex(options.indexes, indexName);
-    if (!index.describe) {
-      throw new Error(`@lunora/bindings/vectors: binding for "${indexName}" does not implement describe()`);
-    }
-    return index.describe();
-  };
-  return { deleteByIds, describe, getByIds, query, upsert, upsertMany };
-};
-
-export { createVectors as default };