@lunora/bindings 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/WindowFunction-DA3pGC3N.mjs

@@ -0,0 +1,82 @@
+import { renderOrderTerm } from './asc-Cur-xO8v.mjs';
+import { lit, toText } from './Sql-DceGtcUd.mjs';
+import WindowExpression from './WindowExpression-Cg9s2xcr.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-Cur-xO8v.mjs

@@ -0,0 +1,16 @@
+import { Sql, toText } from './Sql-DceGtcUd.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-D1sVfIOP.mjs

@@ -0,0 +1,30 @@
+const ABSOLUTE_URL_RE = /^[a-z][a-z\d+\-.]*:\/\//i;
+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);
+  if (serialized.includes(",") || serialized.includes("=")) {
+    throw new Error(
+      `@lunora/bindings/images: transform option \`${key}\` value \`${serialized}\` contains a \`,\` or \`=\`, which the /cdn-cgi/image/ option list cannot represent (these are the option/key-value separators). For colors, use the hex form (e.g. \`#RRGGBB\`/\`%23RRGGBB\`) instead of \`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 Error("@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-Otdgc_jO.mjs

@@ -0,0 +1,113 @@
+const textEncoder = new TextEncoder();
+const MAX_EXPIRES_IN_SECONDS = 7 * 24 * 60 * 60;
+const SCHEME_PREFIX_RE = /^[a-z][a-z\d+\-.]*:\/\//i;
+const LEADING_SLASH_RE = /^\//;
+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;
+  }
+  if (keyCache.size >= KEY_CACHE_MAX) {
+    const oldest = keyCache.keys().next().value;
+    if (oldest !== void 0) {
+      keyCache.delete(oldest);
+    }
+  }
+  const keyPromise = crypto.subtle.importKey("raw", textEncoder.encode(secret), { hash: "SHA-256", name: "HMAC" }, false, ["sign", "verify"]);
+  keyCache.set(secret, keyPromise);
+  return keyPromise;
+};
+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 extractHost = (input) => {
+  try {
+    return new URL(input).host;
+  } catch {
+    const noScheme = input.replace(SCHEME_PREFIX_RE, "");
+    return noScheme.split("/")[0] ?? "";
+  }
+};
+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 Error("@lunora/bindings/images: expiresInSeconds must be a positive finite number");
+  }
+  if (expiresInSeconds > MAX_EXPIRES_IN_SECONDS) {
+    throw new Error(`@lunora/bindings/images: expiresInSeconds must not exceed ${String(MAX_EXPIRES_IN_SECONDS)} (7 days)`);
+  }
+  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 cryptoKey = await importHmacKey(options.secret);
+  const signature = await crypto.subtle.sign("HMAC", cryptoKey, textEncoder.encode(canonicalize(host, normalizedKey, exp, transform)));
+  const sig = toBase64Url(new Uint8Array(signature));
+  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 cryptoKey = await importHmacKey(secret);
+  const valid = await crypto.subtle.verify(
+    "HMAC",
+    cryptoKey,
+    sigBytes,
+    textEncoder.encode(canonicalize(host, key, exp, transform))
+  );
+  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-Dj5sOibv.mjs

@@ -0,0 +1,23 @@
+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;
+  const workers = Array.from({ length: effectiveLimit }, async () => {
+    for (; ; ) {
+      const index = cursor;
+      cursor += 1;
+      if (index >= items.length) {
+        return;
+      }
+      results[index] = await function_(items[index], index);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+};
+
+export { UPSERT_EMBED_CONCURRENCY as U, concurrentMap as c };

package/dist/packem_shared/createAnalytics-CEEI69o9.mjs

@@ -0,0 +1,57 @@
+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-BSizpmu5.mjs

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,141 @@
+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 };