@lunora/bindings 1.0.0-alpha.8 → 1.0.0-alpha.81

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 };

package/dist/packem_shared/createKv-C8Iyu5hD.mjs

@@ -1,145 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const MAX_KEY_LENGTH = 512;
-const MAX_LIST_LIMIT = 1e3;
-const TEXT_ENCODER = new TextEncoder();
-const byteLength = (value) => TEXT_ENCODER.encode(value).length;
-const validateKey = (key) => {
-  if (typeof key !== "string" || key.length === 0) {
-    throw new TypeError("@lunora/bindings/kv: key must be a non-empty string");
-  }
-  if (byteLength(key) > MAX_KEY_LENGTH) {
-    throw new LunoraError("INTERNAL", `@lunora/bindings/kv: key exceeds ${String(MAX_KEY_LENGTH)}-byte limit`);
-  }
-  if (key.includes("\0")) {
-    throw new LunoraError("INTERNAL", "@lunora/bindings/kv: key contains NUL byte");
-  }
-  const segments = key.split("/");
-  for (const segment of segments) {
-    if (segment === "." || segment === "..") {
-      throw new LunoraError("INTERNAL", "@lunora/bindings/kv: key contains a `.`/`..` path component");
-    }
-  }
-};
-const validatePrefix = (prefix) => {
-  if (prefix.length === 0) {
-    return;
-  }
-  if (byteLength(prefix) > MAX_KEY_LENGTH) {
-    throw new LunoraError("INTERNAL", `@lunora/bindings/kv: prefix exceeds ${String(MAX_KEY_LENGTH)}-byte limit`);
-  }
-  if (prefix.includes("\0")) {
-    throw new LunoraError("INTERNAL", "@lunora/bindings/kv: prefix contains NUL byte");
-  }
-  const segments = prefix.split("/");
-  for (const segment of segments) {
-    if (segment === "." || segment === "..") {
-      throw new LunoraError("INTERNAL", "@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 (byteLength(composed) > MAX_KEY_LENGTH) {
-    throw new LunoraError("INTERNAL", `@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 LunoraError("INTERNAL", "@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 TypeError("@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 TypeError("@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/createKvIntrospector-Byk4GfsY.mjs

@@ -1,77 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const createKvIntrospector = (options) => {
-  const { namespaces } = options;
-  const resolveNamespace = (binding) => {
-    const ns = namespaces[binding];
-    if (!Object.hasOwn(namespaces, binding) || ns === void 0) {
-      throw new LunoraError("BAD_REQUEST", `@lunora/bindings/kv: no namespace registered under binding "${binding}"`);
-    }
-    return ns;
-  };
-  const listNamespaces = () => Promise.resolve(
-    Object.keys(namespaces).map((binding) => {
-      return { binding };
-    })
-  );
-  const listKeys = async (listOptions) => {
-    const ns = resolveNamespace(listOptions.namespace);
-    const result = await ns.list({ cursor: listOptions.cursor, limit: listOptions.limit, prefix: listOptions.prefix });
-    const keys = result.keys.map((entry) => {
-      return {
-        expiration: entry.expiration,
-        metadata: entry.metadata,
-        name: entry.name
-      };
-    });
-    return {
-      cursor: result.list_complete ? void 0 : result.cursor,
-      keys,
-      listComplete: result.list_complete
-    };
-  };
-  const getValue = async (getOptions) => {
-    const ns = resolveNamespace(getOptions.namespace);
-    const result = await ns.getWithMetadata(getOptions.key, "text");
-    return { metadata: result.metadata ?? null, value: result.value ?? null };
-  };
-  const putValue = async (putOptions) => {
-    const ns = resolveNamespace(putOptions.namespace);
-    await ns.put(putOptions.key, putOptions.value, {
-      expiration: putOptions.expiration,
-      expirationTtl: putOptions.expirationTtl,
-      metadata: putOptions.metadata
-    });
-  };
-  const deleteKey = async (deleteOptions) => {
-    const ns = resolveNamespace(deleteOptions.namespace);
-    await ns.delete(deleteOptions.key);
-  };
-  return {
-    deleteKey,
-    getValue,
-    listKeys,
-    listNamespaces,
-    putValue
-  };
-};
-const isKvNamespace = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.getWithMetadata === "function" && typeof candidate.list === "function" && typeof candidate.put === "function" && typeof candidate.delete === "function";
-};
-const createKvIntrospectorFromEnv = (env) => {
-  const namespaces = {};
-  if (typeof env === "object" && env !== null) {
-    for (const [binding, value] of Object.entries(env)) {
-      if (isKvNamespace(value)) {
-        namespaces[binding] = value;
-      }
-    }
-  }
-  return createKvIntrospector({ namespaces });
-};
-
-export { createKvIntrospector, createKvIntrospectorFromEnv };

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 };