@auersperg/flare 0.3.9 → 0.3.11

package/dist/sdk/backup.js

@@ -1,6 +1,6 @@
 import { boundedJson, FlareError, stableJson } from "./protocol.js";
 import {
-  documentValue,
+  documentJson,
   quote,
   schemaContract
 } from "./schema.js";
@@ -66,10 +66,10 @@ export async function restoreData(storage, schema, id, snapshot) {
       for (const doc of docs) {
         if (++count > SNAPSHOT_ROWS || !doc || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(doc._id) || !Number.isFinite(doc._creationTime) || doc._creationTime < 0)
           reject("INVALID_BACKUP");
-        const value = await documentValue(schema[name], doc.value);
-        if (stableJson(value) !== stableJson(doc.value))
+        const value = await documentJson(schema[name], doc.value);
+        if (value !== stableJson(doc.value))
           reject("INVALID_BACKUP");
-        storage.sql.exec(`INSERT INTO ${quote(name)} VALUES (?,?,?)`, doc._id, doc._creationTime, stableJson(value));
+        storage.sql.exec(`INSERT INTO ${quote(name)} VALUES (?,?,?)`, doc._id, doc._creationTime, value);
       }
     }
     storage.sql.exec("UPDATE _flared_revision SET value=? WHERE id=1", snapshot.revision);

package/dist/sdk/client.js

@@ -1,3 +1,4 @@
+import { readBody } from "./http.js";
 import {
   assertPath,
   boundedJson,
@@ -37,12 +38,17 @@ export async function uploadFile(grant, file, options = {}) {
       body: file,
       redirect: "error",
       credentials: "omit",
-      signal: options.signal ?? AbortSignal.timeout(options.timeoutMs ?? 120000)
+      signal: AbortSignal.any([
+        ...options.signal ? [options.signal] : [],
+        AbortSignal.timeout(options.timeoutMs ?? 120000)
+      ])
     });
   } catch {
     throw new FlareError("UPLOAD_UNKNOWN", "Connection interrupted or upload timed out; refresh the file list before trying again", true);
   }
-  const result = await response.json().catch(() => null);
+  const result = response.body ? await readBody(response.body, LIMITS.outputBytes, () => {
+    throw Error("Upload response exceeds limit");
+  }).then((bytes) => JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes))).catch(() => null) : null;
   if (!response.ok) {
     const code = result && typeof result === "object" && "error" in result && typeof result.error === "string" ? result.error : `HTTP_${response.status}`;
     throw new FlareError(code, `Upload failed: ${code}`, response.status >= 500);
@@ -77,7 +83,7 @@ export function createClient(options) {
   const notify = (sub, method, value) => {
     for (const observer of sub.observers) {
       try {
-        observer[method]?.(method === "next" ? JSON.parse(stableJson(value)) : value);
+        observer[method]?.(method === "next" ? JSON.parse(value) : value);
       } catch {}
     }
   };
@@ -110,28 +116,9 @@ export function createClient(options) {
       });
       if (!response.body)
         throw new FlareError("INVALID_RESPONSE", "Missing response body", write);
-      const reader = response.body.getReader();
-      let bytes = 0;
-      const chunks = [];
-      try {
-        for (;; ) {
-          const { done, value } = await reader.read();
-          if (done)
-            break;
-          bytes += value.byteLength;
-          if (bytes > LIMITS.outputBytes)
-            throw new FlareError("INVALID_RESPONSE", "Response exceeds limit", write);
-          chunks.push(value);
-        }
-      } finally {
-        await reader.cancel().catch(() => {});
-      }
-      const combined = new Uint8Array(bytes);
-      let offset = 0;
-      for (const chunk of chunks) {
-        combined.set(chunk, offset);
-        offset += chunk.byteLength;
-      }
+      const combined = await readBody(response.body, LIMITS.outputBytes, () => {
+        throw new FlareError("INVALID_RESPONSE", "Response exceeds limit", write);
+      });
       let data;
       try {
         data = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(combined));
@@ -195,7 +182,7 @@ export function createClient(options) {
         attempt = 0;
         for (const sub of subscriptions.values()) {
           sub.revision = -1;
-          sub.hasValue = false;
+          sub.snapshot = undefined;
           if (!sub.terminal)
             register(sub);
         }
@@ -215,8 +202,7 @@ export function createClient(options) {
           if (frame.type === "error") {
             sub.terminal = true;
             if (authorizationErrors.has(frame.code)) {
-              sub.hasValue = false;
-              sub.value = undefined;
+              sub.snapshot = undefined;
             }
             notify(sub, "error", new FlareError(typeof frame.code === "string" ? frame.code : "LIVE_ERROR", "Live subscription failed"));
             return;
@@ -225,12 +211,11 @@ export function createClient(options) {
             throw new Error("Invalid snapshot");
           const json = boundedJson(frame.result, LIMITS.outputBytes);
           if (frame.revision > sub.revision) {
-            const changed = !sub.hasValue || stableJson(sub.value) !== json;
+            const changed = sub.snapshot !== json;
             sub.revision = frame.revision;
-            sub.value = frame.result;
-            sub.hasValue = true;
+            sub.snapshot = json;
             if (changed)
-              notify(sub, "next", sub.value);
+              notify(sub, "next", sub.snapshot);
           }
           send({ type: "ack", id: sub.id, revision: sub.revision });
         } catch {
@@ -244,8 +229,7 @@ export function createClient(options) {
         socket = undefined;
         for (const sub of subscriptions.values()) {
           if (event.code === 1008) {
-            sub.hasValue = false;
-            sub.value = undefined;
+            sub.snapshot = undefined;
             sub.revision = -1;
           }
           if (!sub.terminal)
@@ -271,8 +255,7 @@ export function createClient(options) {
         return;
       for (const sub of subscriptions.values()) {
         if (error instanceof FlareError && authorizationErrors.has(error.code)) {
-          sub.hasValue = false;
-          sub.value = undefined;
+          sub.snapshot = undefined;
           sub.revision = -1;
         }
         notify(sub, "error", error instanceof FlareError ? error : new FlareError("LIVE_UNAVAILABLE", "Live connection failed"));
@@ -319,7 +302,6 @@ export function createClient(options) {
           args: JSON.parse(stableJson(args)),
           observers: new Set,
           revision: -1,
-          hasValue: false,
           terminal: false
         };
         subscriptions.set(key, sub);
@@ -328,8 +310,8 @@ export function createClient(options) {
       }
       const registration = { next: observer.next, error: observer.error };
       sub.observers.add(registration);
-      if (sub.hasValue)
-        notify({ ...sub, observers: new Set([observer]) }, "next", sub.value);
+      if (sub.snapshot !== undefined)
+        notify({ ...sub, observers: new Set([observer]) }, "next", sub.snapshot);
       connect();
       let unsubscribed = false;
       return () => {
@@ -367,8 +349,7 @@ export function createClient(options) {
       socket = undefined;
       old?.close(1000, "Authorization changed");
       for (const sub of subscriptions.values()) {
-        sub.hasValue = false;
-        sub.value = undefined;
+        sub.snapshot = undefined;
         sub.revision = -1;
         sub.terminal = false;
         notify(sub, "error", new FlareError("AUTH_CHANGED", "Authorization changed; cached value invalidated"));

package/dist/sdk/cloudflare.d.ts

@@ -3,6 +3,8 @@ import { type FunctionTree } from "./server.js";
 import { type Auth, type FunctionKind, type Json } from "./protocol.js";
 import { type Schema } from "./schema.js";
 export interface Invocation {
+    /** Trusted Runtime admission only, never copied from public call input. */
+    mcp?: string;
     path: string;
     kind: FunctionKind;
     args: Json;
@@ -98,6 +100,8 @@ export interface ScopedCapability {
     }): Promise<string>;
     download(id: string): Promise<Response>;
     fileCommand(op: string, input: unknown): Promise<any>;
+    codexCommand(op: string, input: unknown): Promise<any>;
+    searchCommand(op: string, input: unknown): Promise<any>;
     scheduleCommand(op: string, input: unknown): Promise<any>;
 }
 /** Construct the class at build time. Parent supplies a verified identity and release ID,

package/dist/sdk/cloudflare.js

@@ -1,3 +1,5 @@
+import { codexContext } from "./codex.js";
+import { searchContext } from "./search.js";
 import { DurableObject, WorkerEntrypoint } from "cloudflare:workers";
 import {
   flatten,
@@ -102,7 +104,7 @@ export function createFacet(app) {
         }
         let result = null;
         const changed = new Set;
-        await this.ctx.storage.transaction(async () => {
+        const revision = await this.ctx.storage.transaction(async () => {
           let active = true;
           const scheduled = [];
           const jobs = Object.freeze({
@@ -136,9 +138,7 @@ export function createFacet(app) {
                 if (!active)
                   throw new FlareError("CAPABILITY_EXPIRED", "Mutation invocation ended");
                 const id = crypto.randomUUID();
-                this.ctx.storage.sql.exec("INSERT INTO _flared_outbox (id,release,path,args,auth,dueAt) VALUES (?,?,?,?,?,?)", id, this.env.RELEASE_ID, path, JSON.stringify(input), JSON.stringify(call.auth), Date.now() + Math.ceil(delay * 1000));
-                if (target.auth === "internal")
-                  this.ctx.storage.sql.exec("UPDATE _flared_outbox SET internal=1,auth='null' WHERE id=?", id);
+                this.ctx.storage.sql.exec("INSERT INTO _flared_outbox (id,release,path,args,auth,dueAt,internal) VALUES (?,?,?,?,?,?,?)", id, this.env.RELEASE_ID, path, JSON.stringify(input), JSON.stringify(target.auth === "internal" ? null : call.auth), Date.now() + Math.ceil(delay * 1000), Number(target.auth === "internal"));
                 return id;
               })();
               scheduled.push(pending);
@@ -161,16 +161,17 @@ export function createFacet(app) {
             capability.revoke();
             await Promise.allSettled(scheduled);
           }
-          this.commitRevision(changed);
+          return this.commitRevision(changed);
         });
         await this.ctx.storage.sync();
-        return { result, revision: this.revision(), tables: [...changed] };
+        return { result, revision, tables: [...changed] };
       });
     }
     commitRevision(changed) {
-      this.ctx.storage.sql.exec("UPDATE _flared_revision SET value=value+1 WHERE id=1");
+      const revision = Number(this.ctx.storage.sql.exec("UPDATE _flared_revision SET value=value+1 WHERE id=1 RETURNING value").one().value);
       for (const name of changed)
-        this.ctx.storage.sql.exec("INSERT INTO _flared_changes VALUES (?,?) ON CONFLICT(name) DO UPDATE SET revision=excluded.revision", name, this.revision());
+        this.ctx.storage.sql.exec("INSERT INTO _flared_changes VALUES (?,?) ON CONFLICT(name) DO UPDATE SET revision=excluded.revision", name, revision);
+      return revision;
     }
     pendingJobs(limit = 100) {
       return this.serial(async () => {
@@ -295,7 +296,7 @@ export function createFacet(app) {
         boundedJson(input, LIMITS.inputBytes);
         let rows = [];
         const changed = new Set;
-        await this.ctx.storage.transaction(async () => {
+        const revision = await this.ctx.storage.transaction(async () => {
           if (input.expectedRevision !== this.revision())
             throw new FlareError("CONFLICT", "Data changed; reload before editing");
           const capability = database(this.ctx.storage.sql, app.schema, true, new Set, changed);
@@ -317,10 +318,10 @@ export function createFacet(app) {
           } finally {
             capability.revoke();
           }
-          this.commitRevision(changed);
+          return this.commitRevision(changed);
         });
         await this.ctx.storage.sync();
-        return { rows, revision: this.revision() };
+        return { rows, revision };
       });
     }
   };
@@ -360,6 +361,8 @@ export function createAction(app) {
       const capability = this.env.CAPABILITY;
       const context = {
         auth: call.auth,
+        codex: codexContext((op, input) => rpcData(capability.codexCommand(op, input))),
+        search: searchContext((op, input) => rpcData(capability.searchCommand(op, input))),
         schedules: {
           set: (input) => rpcData(capability.scheduleCommand("set", input)),
           cancel: (name) => rpcData(capability.scheduleCommand("cancel", { name })),

package/dist/sdk/codex.d.ts

@@ -0,0 +1,20 @@
+export interface CodexTaskInput {
+    /** Stable UUID for retries of the same submission; retained for seven days. */
+    id: string;
+    prompt: string;
+}
+export interface CodexTask {
+    id: string;
+    state: "running" | "succeeded" | "failed" | "cancelled" | "interrupted";
+    startedAt: number;
+    finishedAt?: number;
+    result?: string;
+    error?: string;
+}
+export interface CodexContext {
+    start(input: CodexTaskInput): Promise<CodexTask>;
+    status(id: string): Promise<CodexTask | null>;
+    cancel(id: string): Promise<CodexTask | null>;
+}
+export declare function codexInput(op: string, input: any): void;
+export declare function codexContext(call: (op: string, input: unknown) => Promise<any>): CodexContext;

package/dist/sdk/codex.js

@@ -0,0 +1,17 @@
+import { FlareError, boundedJson } from "./protocol.js";
+export function codexInput(op, input) {
+  boundedJson(input, 20000);
+  if (!input || Array.isArray(input) || !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(input.id) || !["start", "status", "cancel"].includes(op) || Object.keys(input).some((k) => !["id", ...op === "start" ? ["prompt"] : []].includes(k)) || op === "start" && (typeof input.prompt !== "string" || !input.prompt.trim() || new TextEncoder().encode(input.prompt).length > 16384))
+    throw new FlareError("INVALID_ARGUMENT", "Invalid Codex task");
+}
+export function codexContext(call) {
+  const invoke = (op, input) => {
+    codexInput(op, input);
+    return call(op, input);
+  };
+  return {
+    start: (input) => invoke("start", input),
+    status: (id) => invoke("status", { id }),
+    cancel: (id) => invoke("cancel", { id })
+  };
+}

package/dist/sdk/database.js

@@ -1,6 +1,6 @@
 import { FlareError, boundedJson, stableJson } from "./protocol.js";
 import {
-  documentValue,
+  documentJson,
   fieldSql,
   quote
 } from "./schema.js";
@@ -64,7 +64,7 @@ export function database(sql, schema, writable, touched = new Set, changed = new
   function query(name) {
     const definition = table(name);
     function make(index, filters, direction) {
-      const page = (options) => task(async () => {
+      const page = (options, withCursor = true) => task(async () => {
         table(name);
         size(options.limit);
         const fields = [
@@ -73,9 +73,18 @@ export function database(sql, schema, writable, touched = new Set, changed = new
           "_id"
         ];
         const expressions = fields.map(fieldSql);
-        const signature = stableJson({ name, index, filters, direction });
+        const signature = withCursor ? stableJson({ name, index, filters, direction }) : "";
+        const fixed = filters.filter((f) => f.operator === "=");
         const where = filters.map((f) => `${fieldSql(f.field)} ${f.operator === "=" ? "IS" : f.operator} ?`);
         const bindings = filters.map((f) => bind(f.value));
+        const rowLimit = options.limit + (withCursor ? 1 : 0);
+        const rows = [];
+        const read = (terms = [], values = [], orderStart = fixed.length) => {
+          if (rows.length >= rowLimit)
+            return;
+          const conditions = [...terms, ...where];
+          rows.push(...sql.exec(`SELECT *${withCursor ? "," + expressions.map((e, i) => `${e} AS __k${i}`).join(",") : ""} FROM ${quote(name)} ${conditions.length ? "WHERE " + conditions.join(" AND ") : ""} ORDER BY ${expressions.slice(orderStart).map((e) => `${e} ${direction}`).join(",")} LIMIT ?`, ...values, ...bindings, rowLimit - rows.length).toArray());
+        };
         if (options.cursor != null) {
           let token;
           try {
@@ -85,23 +94,32 @@ export function database(sql, schema, writable, touched = new Set, changed = new
           } catch {
             throw new FlareError("INVALID_CURSOR", "Invalid cursor");
           }
-          if (token.signature !== signature || !Array.isArray(token.values) || token.values.length !== fields.length || !token.values.every(scalar))
+          if (!token || token.signature !== signature || !Array.isArray(token.values) || token.values.length !== fields.length || !token.values.every(scalar) || typeof token.values.at(-2) !== "number" || typeof token.values.at(-1) !== "string")
             throw new FlareError("INVALID_CURSOR", "Cursor belongs to a different query");
-          const terms = expressions.map((expr, i) => {
-            const prefix = expressions.slice(0, i).map((e) => `${e} IS ?`);
-            bindings.push(...token.values.slice(0, i).map(bind));
-            const value = token.values[i];
-            if (value === null)
-              prefix.push(direction === "asc" ? `${expr} IS NOT NULL` : "0");
-            else {
-              prefix.push(direction === "asc" ? `${expr} > ?` : `(${expr} < ? OR ${expr} IS NULL)`);
-              bindings.push(bind(value));
+          if (fixed.some((f, i) => bind(f.value) !== bind(token.values[i])))
+            throw new FlareError("INVALID_CURSOR", "Cursor violates index range");
+          const first = fixed.length;
+          for (let i = expressions.length - 2;i >= first && rows.length < rowLimit; i--) {
+            const prefix = expressions.slice(first, i).map((e) => `${e} IS ?`);
+            const values = token.values.slice(first, i).map(bind);
+            const expr = expressions[i], value = token.values[i];
+            if (i === expressions.length - 2) {
+              read([
+                ...prefix,
+                `(${expressions.slice(i).join(",")}) ${direction === "asc" ? ">" : "<"} (?,?)`
+              ], [...values, ...token.values.slice(i).map(bind)], i);
+            } else if (direction === "asc") {
+              read([
+                ...prefix,
+                value === null ? `${expr} IS NOT NULL` : `${expr} > ?`
+              ], value === null ? values : [...values, bind(value)], i);
+            } else if (value !== null) {
+              read([...prefix, `${expr} < ?`], [...values, bind(value)], i);
+              read([...prefix, `${expr} IS NULL`], values, i + 1);
             }
-            return "(" + prefix.join(" AND ") + ")";
-          });
-          where.push("(" + terms.join(" OR ") + ")");
-        }
-        const rows = sql.exec(`SELECT *,${expressions.map((e, i) => `${e} AS __k${i}`).join(",")} FROM ${quote(name)} ${where.length ? "WHERE " + where.join(" AND ") : ""} ORDER BY ${expressions.map((e) => `${e} ${direction}`).join(",")} LIMIT ?`, ...bindings, options.limit + 1).toArray();
+          }
+        } else
+          read();
         let more = rows.length > options.limit;
         if (more)
           rows.pop();
@@ -117,7 +135,7 @@ export function database(sql, schema, writable, touched = new Set, changed = new
           bytes += length;
         }
         const last = rows[docs.length - 1];
-        const continueCursor = more && last ? btoa(String.fromCharCode(...new TextEncoder().encode(boundedJson({
+        const continueCursor = withCursor && more && last ? btoa(String.fromCharCode(...new TextEncoder().encode(boundedJson({
           signature,
           values: expressions.map((_, i) => last[`__k${i}`])
         }, 6144)))) : null;
@@ -174,14 +192,14 @@ export function database(sql, schema, writable, touched = new Set, changed = new
         paginate: page,
         take(limit) {
           return task(async () => {
-            const result = await page({ limit });
+            const result = await page({ limit }, false);
             if (!result.isDone && result.page.length < limit)
               throw new FlareError("TOO_LARGE", "Use paginate for large documents");
             return result.page;
           }, false);
         },
         first() {
-          return task(async () => (await page({ limit: 1 })).page[0] ?? null, false);
+          return task(async () => (await page({ limit: 1 }, false)).page[0] ?? null, false);
         }
       });
     }
@@ -192,10 +210,10 @@ export function database(sql, schema, writable, touched = new Set, changed = new
     insert(name, input) {
       return task(async () => {
         writing();
-        const definition = table(name), value = await documentValue(definition, input);
+        const definition = table(name), value = await documentJson(definition, input);
         writing();
         const id = crypto.randomUUID();
-        sql.exec(`INSERT INTO ${quote(name)} VALUES (?,?,?)`, id, Date.now(), stableJson(value));
+        sql.exec(`INSERT INTO ${quote(name)} VALUES (?,?,?)`, id, Date.now(), value);
         changed.add(name);
         return id;
       });
@@ -211,12 +229,12 @@ export function database(sql, schema, writable, touched = new Set, changed = new
         const row = sql.exec(`SELECT _data FROM ${quote(name)} WHERE _id=?`, id).toArray()[0];
         if (!row)
           throw new FlareError("NOT_FOUND", "Document not found");
-        const value = await documentValue(definition, {
+        const value = await documentJson(definition, {
           ...JSON.parse(String(row._data)),
           ...patch
         });
         writing();
-        sql.exec(`UPDATE ${quote(name)} SET _data=? WHERE _id=?`, stableJson(value), id);
+        sql.exec(`UPDATE ${quote(name)} SET _data=? WHERE _id=?`, value, id);
         changed.add(name);
       });
     },
@@ -225,9 +243,9 @@ export function database(sql, schema, writable, touched = new Set, changed = new
         writing();
         const definition = table(name);
         checkedId(id);
-        const value = await documentValue(definition, input);
+        const value = await documentJson(definition, input);
         writing();
-        const rows = sql.exec(`UPDATE ${quote(name)} SET _data=? WHERE _id=? RETURNING _id`, stableJson(value), id).toArray();
+        const rows = sql.exec(`UPDATE ${quote(name)} SET _data=? WHERE _id=? RETURNING _id`, value, id).toArray();
         if (!rows.length)
           throw new FlareError("NOT_FOUND", "Document not found");
         changed.add(name);

package/dist/sdk/http.d.ts

@@ -0,0 +1,2 @@
+/** Internal bounded transport reader shared by the SDK and platform. */
+export declare function readBody(body: ReadableStream<Uint8Array>, limit: number, tooLarge: () => never): Promise<Uint8Array>;

package/dist/sdk/http.js

@@ -0,0 +1,27 @@
+export async function readBody(body, limit, tooLarge) {
+  const reader = body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      size += value.byteLength;
+      if (size > limit)
+        tooLarge();
+      chunks.push(value);
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+  if (chunks.length === 1)
+    return chunks[0];
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}

package/dist/sdk/protocol.d.ts

@@ -34,7 +34,13 @@ export declare function reference<I, O>(path: string, kind: FunctionKind): Funct
 /** Lossless JSON only: no implicit Date, undefined, NaN or prototype coercion. */
 export declare function stableJson(value: unknown): string;
 export declare function boundedJson(value: unknown, maxBytes: number): string;
+export type McpTool = {
+    name: string;
+    description: string;
+};
+export declare function assertMcpTools(functions: Record<string, FunctionContract>): void;
 export interface FunctionContract {
+    mcp?: McpTool;
     kind: FunctionKind;
     auth: "required" | "public" | "internal";
     input: Record<string, unknown>;

package/dist/sdk/protocol.js

@@ -74,3 +74,15 @@ export function boundedJson(value, maxBytes) {
     throw new FlareError("TOO_LARGE", "JSON payload exceeds limit");
   return json;
 }
+export function assertMcpTools(functions) {
+  const names = new Set;
+  for (const fn of Object.values(functions)) {
+    if (fn.mcp === undefined)
+      continue;
+    const m = fn.mcp;
+    if (!m || typeof m !== "object" || Object.keys(m).sort().join() !== "description,name" || typeof m.name !== "string" || !/^[A-Za-z][A-Za-z0-9_.-]{0,63}$/.test(m.name) || typeof m.description !== "string" || !m.description.trim() || m.description.length > 1000 || names.has(m.name) || fn.auth === "internal" || fn.input.type !== "object")
+      throw new FlareError("INVALID_CONTRACT", "Invalid MCP tool contract");
+    boundedJson({ mcp: m, input: fn.input }, 16384);
+    names.add(m.name);
+  }
+}

package/dist/sdk/schema.d.ts

@@ -1,5 +1,4 @@
 import type { StandardSchemaV1, StandardJSONSchemaV1 } from "@standard-schema/spec";
-import { type Json } from "./protocol.js";
 export type SqlValue = ArrayBuffer | string | number | null;
 /** The small structural portion of native storage needed by the adapter; no Worker globals in public types. */
 export interface NativeSql {
@@ -39,5 +38,6 @@ export declare function defineTable<V extends Validator>(validator: V): Table<V,
 export declare function schemaContract(schema: Schema): SchemaContract;
 export declare function assertSchemaContract(contract: SchemaContract): void;
 export declare function defineSchema<const S extends Schema>(schema: S): S;
-export declare function documentValue(table: TableDefinition, input: unknown): Promise<Record<string, Json>>;
+/** Validate once and return the canonical JSON written by all storage paths. */
+export declare function documentJson(table: TableDefinition, input: unknown): Promise<string>;
 export declare function applySchema(storage: NativeStorage, schema: Schema): Promise<void>;

package/dist/sdk/schema.js

@@ -92,7 +92,7 @@ function documentSchema(table) {
   }
   return doc;
 }
-export async function documentValue(table, input) {
+export async function documentJson(table, input) {
   boundedJson(input, 65536);
   const properties = documentSchema(table).properties ?? {};
   if (!input || Array.isArray(input) || typeof input !== "object" || Object.keys(input).some((k) => !Object.hasOwn(properties, k)))
@@ -100,7 +100,7 @@ export async function documentValue(table, input) {
   const result = await table.validator["~standard"].validate(input);
   if (result.issues || !result.value || Array.isArray(result.value) || typeof result.value !== "object" || Object.keys(result.value).some((k) => !Object.hasOwn(properties, k)))
     throw new FlareError("INVALID_INPUT", "Document failed schema validation");
-  return JSON.parse(boundedJson(result.value, 65536));
+  return boundedJson(result.value, 65536);
 }
 export async function applySchema(storage, schema) {
   const contract = schemaContract(schema), encoded = stableJson(contract);
@@ -118,13 +118,14 @@ export async function applySchema(storage, schema) {
       }
     for (const [name, definition] of Object.entries(contract)) {
       storage.sql.exec(`CREATE TABLE IF NOT EXISTS ${quote(name)} (_id TEXT PRIMARY KEY, _creationTime REAL NOT NULL, _data TEXT NOT NULL CHECK(json_valid(_data)))`);
+      const changed = !old[name] || stableJson(old[name].document) !== stableJson(definition.document);
       let cursor = "";
-      while (!old[name] || stableJson(old[name].document) !== stableJson(definition.document)) {
+      while (changed) {
         const rows = storage.sql.exec(`SELECT _id,_data FROM ${quote(name)} WHERE _id > ? ORDER BY _id LIMIT 100`, cursor).toArray();
         for (const row of rows) {
-          const value = await documentValue(schema[name], JSON.parse(String(row._data)));
-          if (stableJson(value) !== stableJson(JSON.parse(String(row._data))))
-            storage.sql.exec(`UPDATE ${quote(name)} SET _data=? WHERE _id=?`, stableJson(value), row._id);
+          const value = await documentJson(schema[name], JSON.parse(String(row._data)));
+          if (value !== stableJson(JSON.parse(String(row._data))))
+            storage.sql.exec(`UPDATE ${quote(name)} SET _data=? WHERE _id=?`, value, row._id);
         }
         if (rows.length < 100)
           break;

package/dist/sdk/search.d.ts

@@ -0,0 +1,25 @@
+import { type Json } from "./protocol.js";
+export type SearchState = {
+    fileId: string;
+    enabled: boolean;
+    status: "excluded" | "pending" | "sending" | "queued" | "running" | "completed" | "error" | "skipped" | "outdated" | "deleting";
+    error: string | null;
+};
+export type SearchHit = {
+    fileId: string;
+    name: string;
+    text: string;
+    score: number;
+};
+export interface SearchContext {
+    index(fileId: string): Promise<SearchState>;
+    exclude(fileId: string): Promise<SearchState>;
+    status(fileId: string): Promise<SearchState>;
+    query(input: {
+        query: string;
+        limit?: number;
+        fileIds?: string[];
+    }, authorize: (fileIds: string[]) => Promise<string[]>): Promise<SearchHit[]>;
+}
+/** Runs in the trusted action, never in browser code. ACLs remain application data. */
+export declare function searchContext(command: (op: string, input: Json) => Promise<any>): SearchContext;

package/dist/sdk/search.js

@@ -0,0 +1,22 @@
+import { FlareError } from "./protocol.js";
+export function searchContext(command) {
+  return {
+    index: (fileId) => command("index", { fileId }),
+    exclude: (fileId) => command("exclude", { fileId }),
+    status: (fileId) => command("status", { fileId }),
+    async query(input, authorize) {
+      if (typeof authorize !== "function")
+        throw new FlareError("FORBIDDEN", "A current file access check is required");
+      const hits = await command("query", input);
+      if (!hits.length)
+        return [];
+      const ids = [...new Set(hits.map((h) => h.fileId))];
+      const allowed = await authorize(ids);
+      if (!Array.isArray(allowed) || allowed.some((id) => !ids.includes(id)))
+        throw new FlareError("FORBIDDEN", "Invalid file access result");
+      const current = await command("validate", { fileIds: allowed });
+      const visible = new Set(current);
+      return hits.filter((h) => visible.has(h.fileId));
+    }
+  };
+}