@lunora/bindings 0.0.0 → 1.0.0-alpha.2

package/dist/vectors/index.d.ts

@@ -0,0 +1,285 @@
+/**
+* Minimal structural projection of `VectorizeIndex` so unit tests can pass a
+* plain-object double and the real Cloudflare binding satisfies the same shape.
+* Mirrors the surface documented at
+* https://developers.cloudflare.com/vectorize/reference/client-api/.
+*/
+interface VectorizeIndexLike {
+  deleteByIds: (ids: ReadonlyArray<string>) => Promise<VectorizeDeleteMutation>;
+  describe?: () => Promise<VectorizeIndexDetails>;
+  getByIds: (ids: ReadonlyArray<string>) => Promise<ReadonlyArray<VectorizeVector>>;
+  insert: (vectors: ReadonlyArray<VectorizeVector>) => Promise<VectorizeUpsertMutation>;
+  query: (vector: ReadonlyArray<number>, options?: VectorizeQueryOptions) => Promise<VectorizeMatches>;
+  upsert: (vectors: ReadonlyArray<VectorizeVector>) => Promise<VectorizeUpsertMutation>;
+}
+type VectorMetric = "cosine" | "euclidean" | "dot-product";
+interface VectorizeVector {
+  id: string;
+  metadata?: Record<string, unknown>;
+  namespace?: string;
+  values: ReadonlyArray<number>;
+}
+interface VectorizeQueryOptions {
+  filter?: Record<string, unknown>;
+  namespace?: string;
+  returnMetadata?: "none" | "indexed" | "all";
+  returnValues?: boolean;
+  topK?: number;
+}
+interface VectorizeMatch {
+  id: string;
+  metadata?: Record<string, unknown>;
+  namespace?: string;
+  score: number;
+  values?: ReadonlyArray<number>;
+}
+interface VectorizeMatches {
+  count: number;
+  matches: ReadonlyArray<VectorizeMatch>;
+}
+interface VectorizeUpsertMutation {
+  mutationId: string;
+}
+interface VectorizeDeleteMutation {
+  count?: number;
+  mutationId: string;
+}
+interface VectorizeIndexDetails {
+  dimensions: number;
+  processedUpToDatetime?: string;
+  processedUpToMutation?: string;
+  vectorsCount: number;
+}
+/**
+* Bring-your-own-embedder: a user-supplied async fn that converts a single
+* source value (a row, a chunk, an arbitrary string) into a numeric vector.
+* The runtime calls this at upsert time so we don't couple to any provider.
+*/
+type EmbedFunction<TInput = unknown> = (input: TInput) => Promise<ReadonlyArray<number>> | ReadonlyArray<number>;
+interface LunoraVectorsOptions {
+  /**
+  * Map of logical index name -> Vectorize binding. Most apps wire one
+  * binding per index; multi-index apps register all of them here so calls
+  * like `vectors.query("docs-body", ...)` can resolve to the right binding.
+  */
+  indexes: Record<string, VectorizeIndexLike>;
+}
+interface UpsertInput<TInput = unknown> {
+  embed: EmbedFunction<TInput>;
+  id: string;
+  input: TInput;
+  metadata?: Record<string, unknown>;
+  namespace?: string;
+}
+interface QueryInput<TInput = unknown> {
+  embed?: EmbedFunction<TInput>;
+  filter?: Record<string, unknown>;
+  input?: TInput;
+  namespace?: string;
+  returnMetadata?: "none" | "indexed" | "all";
+  returnValues?: boolean;
+  topK?: number;
+  /** Either a precomputed vector or a value to embed via `embed`. */
+  vector?: ReadonlyArray<number>;
+}
+interface LunoraVectors {
+  deleteByIds: (indexName: string, ids: ReadonlyArray<string>) => Promise<VectorizeDeleteMutation>;
+  describe: (indexName: string) => Promise<VectorizeIndexDetails>;
+  getByIds: (indexName: string, ids: ReadonlyArray<string>) => Promise<ReadonlyArray<VectorizeVector>>;
+  query: <TInput>(indexName: string, input: QueryInput<TInput>) => Promise<VectorizeMatches>;
+  upsert: <TInput>(indexName: string, input: UpsertInput<TInput>) => Promise<VectorizeUpsertMutation>;
+  upsertMany: <TInput>(indexName: string, inputs: ReadonlyArray<UpsertInput<TInput>>) => Promise<VectorizeUpsertMutation>;
+}
+/**
+* `(input: string) => vector`. Matches `@lunora/server`'s `VectorEmbedder` so
+* the bridged surface is assignable to the server's `VectorSearch` contract.
+*/
+type VectorEmbedderLike = (input: string) => Promise<ReadonlyArray<number>> | ReadonlyArray<number>;
+interface VectorMatchLike {
+  id: string;
+  metadata?: Record<string, unknown>;
+  score: number;
+}
+interface VectorMatchesLike {
+  count: number;
+  matches: ReadonlyArray<VectorMatchLike>;
+}
+interface VectorRecordLike {
+  id: string;
+  metadata?: Record<string, unknown>;
+  values: ReadonlyArray<number>;
+}
+interface VectorQueryInputLike {
+  embed?: VectorEmbedderLike;
+  filter?: Record<string, unknown>;
+  input?: string;
+  namespace?: string;
+  /**
+  * How much stored metadata to return on matches. Defaults to `"indexed"`
+  * (only fields declared as index metadata) rather than `"all"`, so a query
+  * never leaks arbitrary stored fields by default. Callers that genuinely
+  * need every field opt in with `"all"`; pass `"none"` to drop metadata.
+  */
+  returnMetadata?: "none" | "indexed" | "all";
+  topK?: number;
+  vector?: ReadonlyArray<number>;
+}
+interface VectorUpsertInputLike {
+  embed: VectorEmbedderLike;
+  id: string;
+  input: string;
+  metadata?: Record<string, unknown>;
+  namespace?: string;
+}
+/**
+* Structural mirror of `@lunora/server`'s `VectorSearch`. Declared here so the
+* adapter never imports `@lunora/server` (keeps the dependency edge one-way:
+* the generated DO depends on both, neither depends on the other).
+*/
+interface VectorSearchLike {
+  deleteByIds: (indexName: string, ids: ReadonlyArray<string>) => Promise<void>;
+  getByIds: (indexName: string, ids: ReadonlyArray<string>) => Promise<ReadonlyArray<VectorRecordLike>>;
+  query: (indexName: string, input: VectorQueryInputLike) => Promise<VectorMatchesLike>;
+  upsert: (indexName: string, input: VectorUpsertInputLike) => Promise<void>;
+  upsertNow: (indexName: string, input: VectorUpsertInputLike) => Promise<void>;
+}
+/**
+* Bridge `LunoraVectors` (returns Vectorize mutation receipts) to the server's
+* `VectorSearch` contract (void mutations, server match/record shapes). Both
+* `upsert` and `upsertNow` write inline — this design has no post-commit queue,
+* so "now" and "deferred" collapse to the same synchronous call.
+*/
+declare const createContextVectors: (lunora: LunoraVectors) => VectorSearchLike;
+/** A single row mutation observed by the ctx-db, fed to {@link createVectorSyncHook}. */
+interface WriteEvent {
+  doc?: Record<string, unknown>;
+  id: string;
+  op: "delete" | "insert" | "update";
+  table: string;
+}
+type WriteHook = (event: WriteEvent) => Promise<void>;
+/** Inline vector index declared via `.vectorize(field, ...)` (DSL Shape A). */
+interface TableVectorIndexLike {
+  embed: VectorEmbedderLike;
+  field: string;
+  metadata?: ReadonlyArray<string>;
+  name: string;
+}
+interface TableDefinitionLike {
+  vectorIndexes?: ReadonlyArray<TableVectorIndexLike>;
+}
+/** Standalone vector index declared via `defineVectorIndex(...)` (DSL Shape B). */
+interface VectorIndexDefinitionLike {
+  embed: VectorEmbedderLike;
+  metadata?: (row: Record<string, unknown>) => Record<string, unknown>;
+  select: (row: Record<string, unknown>) => string;
+  table: string;
+}
+/**
+* Structural mirror of `@lunora/server`'s `Schema`, narrowed to the fields the
+* sync hook reads. Carries live `embed`/`select` closures, so the hook must be
+* built from the imported `schema` value — never a serialized descriptor.
+*/
+interface SchemaLike {
+  tables: Record<string, TableDefinitionLike>;
+  vectorIndexes: Record<string, VectorIndexDefinitionLike>;
+}
+/**
+* Build a {@link WriteHook} that keeps Vectorize in sync with row writes. On
+* insert/update it embeds each matching index's source (Shape A `row[field]`,
+* Shape B `select(row)`) and upserts; on delete it removes the row's id from
+* every index sourced from the table. Runs inline within the write path.
+*
+* Tenant isolation — IMPORTANT: Vectorize indexes are account-global and shared
+* by every shard DO. Without a `namespace`, a multi-tenant sharded app has NO
+* isolation between tenants in the vector index — one tenant's vectors are
+* queryable by another (ids/scores leak existence + semantic similarity even
+* when no metadata is indexed). The caller MUST pass `options.namespace` (the
+* shard / tenant key) so upserts are scoped, and MUST apply the same namespace
+* on the query side — query-side namespace filtering is mandatory, not optional.
+* The namespace is threaded onto upserts here; pass it from the shard DO that
+* owns this hook. Any namespace-less sync emits a one-time-per-index dev warning
+* (regardless of whether metadata is present); a genuinely single-tenant app
+* suppresses it with `allowSharedNamespace: true`.
+*
+* Consistency — IMPORTANT: this hook runs inline within the mutation but talks
+* to Vectorize, which is external and non-transactional. The per-index calls
+* fan out; if one fails after others have already applied, the SQLite write may
+* roll back while the applied Vectorize mutations cannot — leaving SQLite and
+* Vectorize diverged. We mitigate, not eliminate: upserts/deletes are
+* idempotent (keyed by row id), so a retry of the same write converges; and on
+* a fan-out failure we attempt a best-effort compensating delete of the row's
+* id from every affected index before re-throwing. A delete after a failed
+* upsert can itself fail — this is best-effort, the authoritative recovery is
+* re-running the (idempotent) write.
+*/
+declare const createVectorSyncHook: (options: {
+  allowSharedNamespace?: boolean;
+  namespace?: string;
+  schema: SchemaLike;
+  vectors: VectorSearchLike;
+}) => WriteHook;
+/**
+* One vector index as the generated `LUNORA_VECTOR_INDEXES` registry describes
+* it — the static schema shape, independent of any live binding. Structurally
+* the codegen `LunoraVectorIndex`, restated here so this package stays free of a
+* dependency on `@lunora/codegen`.
+*/
+interface VectorIndexRegistryEntry {
+  dimensions?: number;
+  field?: string;
+  metadata?: ReadonlyArray<string>;
+  metric?: VectorMetric;
+  name: string;
+  table: string;
+}
+/** A registry entry merged with the live `describe()` stats (when the binding is reachable). */
+interface VectorAdminIndexSummary extends VectorIndexRegistryEntry {
+  processedUpToMutation?: string;
+  vectorsCount?: number;
+}
+/** One nearest-neighbour hit from an admin similarity query. */
+interface VectorAdminQueryMatch {
+  id: string;
+  metadata?: Record<string, unknown>;
+  score: number;
+}
+/**
+* The admin introspector the worker passes to `createWorker({ vectorIntrospector })`.
+* `queryIndex` is present only when at least one embedder is wired.
+*/
+interface VectorAdminIntrospector {
+  listIndexes: () => Promise<VectorAdminIndexSummary[]>;
+  queryIndex?: (options: {
+    name: string;
+    text: string;
+    topK?: number;
+  }) => Promise<{
+    matches: VectorAdminQueryMatch[];
+  }>;
+}
+interface VectorAdminIntrospectorOptions {
+  /**
+  * Per-index embedder (text → vector), keyed by index name. Supply the
+  * schema's embedders to enable studio similarity queries; omit it (or leave
+  * an index out) and that index lists read-only — `queryIndex` is withheld
+  * entirely when no embedder is provided.
+  */
+  embedders?: Record<string, EmbedFunction<string>>;
+  /** Live Vectorize bindings keyed by index name, from `env`. */
+  indexes: Record<string, VectorizeIndexLike>;
+  /** The generated `LUNORA_VECTOR_INDEXES` registry (Vectorize can't enumerate at runtime). */
+  registry: ReadonlyArray<VectorIndexRegistryEntry>;
+}
+/**
+* Build the read-only Vectorize introspector backing the studio's vector
+* browser. `listIndexes` returns the static registry, enriching each entry with
+* live `describe()` stats when the matching binding is present (a binding that
+* throws or lacks `describe` degrades to the static shape rather than failing
+* the whole list). `queryIndex` embeds the query text via the index's embedder
+* and runs an ANN search; it is omitted when no embedders are configured, so the
+* worker reports `VECTOR_QUERY_UNSUPPORTED` rather than half-answering.
+*/
+declare const createVectorAdminIntrospector: (options: VectorAdminIntrospectorOptions) => VectorAdminIntrospector;
+declare const createVectors: (options: LunoraVectorsOptions) => LunoraVectors;
+export { type EmbedFunction, type LunoraVectors, type LunoraVectorsOptions, type QueryInput, type SchemaLike, type TableDefinitionLike, type TableVectorIndexLike, type UpsertInput, type VectorAdminIndexSummary, type VectorAdminIntrospector, type VectorAdminIntrospectorOptions, type VectorAdminQueryMatch, type VectorEmbedderLike, type VectorIndexDefinitionLike, type VectorIndexRegistryEntry, type VectorMatchLike, type VectorMatchesLike, type VectorMetric, type VectorQueryInputLike, type VectorRecordLike, type VectorSearchLike, type VectorUpsertInputLike, type VectorizeDeleteMutation, type VectorizeIndexDetails, type VectorizeIndexLike, type VectorizeMatch, type VectorizeMatches, type VectorizeQueryOptions, type VectorizeUpsertMutation, type VectorizeVector, type WriteEvent, type WriteHook, createContextVectors, createVectorAdminIntrospector, createVectorSyncHook, createVectors };

package/dist/vectors/index.mjs

@@ -0,0 +1,3 @@
+export { createContextVectors, createVectorSyncHook } from '../packem_shared/createContextVectors-BSizpmu5.mjs';
+export { createVectorAdminIntrospector } from '../packem_shared/createVectorAdminIntrospector-BJUOM6VW.mjs';
+export { default as createVectors } from '../packem_shared/createVectors-LSpGoKCd.mjs';

package/package.json

@@ -1,19 +1,69 @@
 {
   "name": "@lunora/bindings",
-  "version": "0.0.0",
-  "description": "Placeholder to reserve the npm name. Real releases are published from CI — install the latest version.",
+  "version": "1.0.0-alpha.2",
+  "description": "Lightweight Cloudflare binding helpers for Lunora — ctx.kv, ctx.images, ctx.analytics, ctx.pipelines, ctx.vectors, ctx.r2sql — one install, per-binding subpaths",
+  "keywords": [
+    "analytics",
+    "cloudflare",
+    "images",
+    "kv",
+    "lunora",
+    "pipelines",
+    "r2-sql",
+    "vectorize",
+    "workers"
+  ],
+  "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
   "license": "FSL-1.1-Apache-2.0",
   "author": {
     "name": "Daniel Bannert",
     "email": "d.bannert@anolilab.de"
   },
-  "homepage": "https://lunora.sh",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anolilab/lunora.git",
     "directory": "packages/bindings"
   },
+  "files": [
+    "./dist",
+    "README.md",
+    "LICENSE.md",
+    "__assets__"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./kv": {
+      "types": "./dist/kv/index.d.ts",
+      "import": "./dist/kv/index.mjs"
+    },
+    "./images": {
+      "types": "./dist/images/index.d.ts",
+      "import": "./dist/images/index.mjs"
+    },
+    "./analytics": {
+      "types": "./dist/analytics/index.d.ts",
+      "import": "./dist/analytics/index.mjs"
+    },
+    "./pipelines": {
+      "types": "./dist/pipelines/index.d.ts",
+      "import": "./dist/pipelines/index.mjs"
+    },
+    "./vectors": {
+      "types": "./dist/vectors/index.d.ts",
+      "import": "./dist/vectors/index.mjs"
+    },
+    "./r2sql": {
+      "types": "./dist/r2sql/index.d.ts",
+      "import": "./dist/r2sql/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
   }
-}
+}