@lunora/bindings 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/Sql-B3zq2YGx.mjs

@@ -0,0 +1,74 @@
+const quoteString = (value) => `'${value.replaceAll("'", "''")}'`;
+const IDENTIFIER_RE = /^\w+(?:\.\w+)*$/;
+const TABLE_REF_RE = /^\w+(?:\.\w+)*(?:\s+(?:as\s+)?\w+)?$/i;
+const MAX_LIMIT = 1e4;
+class Sql {
+  text;
+  constructor(text) {
+    this.text = text;
+  }
+  toString() {
+    return this.text;
+  }
+}
+const isSql = (value) => value instanceof Sql;
+const raw = (text) => new Sql(text);
+const toText = (value) => isSql(value) ? value.text : value;
+const ident = (name) => {
+  if (typeof name !== "string" || !IDENTIFIER_RE.test(name)) {
+    throw new TypeError(`r2sql: invalid identifier ${JSON.stringify(name)} — expected dotted [A-Za-z0-9_] segments (e.g. "namespace.table").`);
+  }
+  return name;
+};
+const tableRef = (ref) => {
+  if (typeof ref !== "string" || !TABLE_REF_RE.test(ref)) {
+    throw new TypeError(`r2sql: invalid table reference ${JSON.stringify(ref)} — expected "namespace.table" with an optional "[AS] alias".`);
+  }
+  return ref;
+};
+const lit = (value) => {
+  if (value === null || value === void 0) {
+    return "NULL";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError(`r2sql: cannot inline a non-finite number (${String(value)}) as a SQL literal.`);
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return quoteString(value);
+  }
+  if (value instanceof Date) {
+    return quoteString(value.toISOString());
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      throw new TypeError("r2sql: cannot inline an empty array — `IN ()` is not valid SQL. Guard the empty case before building the query.");
+    }
+    return `(${value.map((element) => lit(element)).join(", ")})`;
+  }
+  throw new TypeError(`r2sql: cannot inline a value of type ${typeof value} as a SQL literal. Wrap trusted SQL with raw(), or pass a primitive/Date/array.`);
+};
+const sql = (strings, ...values) => {
+  let out = strings[0] ?? "";
+  for (const [index, value] of values.entries()) {
+    out += isSql(value) ? value.text : lit(value);
+    out += strings[index + 1] ?? "";
+  }
+  return new Sql(out);
+};
+const joinSql = (parts, separator) => new Sql(parts.map((part) => toText(part)).join(separator));
+const assertLimit = (n) => {
+  if (!Number.isInteger(n) || n < 1 || n > MAX_LIMIT) {
+    throw new RangeError(`r2sql: limit must be an integer between 1 and ${String(MAX_LIMIT)} (got ${String(n)}).`);
+  }
+};
+
+export { Sql, assertLimit, ident, isSql, joinSql, lit, raw, sql, tableRef, toText };

package/dist/packem_shared/WindowExpression-BT_uA6g1.mjs

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

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

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

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

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

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

@@ -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-DwZtnPeC.mjs

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