@auersperg/flare 0.3.10 → 0.3.12

package/dist/sdk/client.d.ts

@@ -1,3 +1,5 @@
+import { type CodexSubscription } from "./codex-stream.js";
+export type { CodexEvent, CodexSubscription } from "./codex-stream.js";
 import { FlareError, type FunctionRef } from "./protocol.js";
 export { reference, FlareError } from "./protocol.js";
 export type { FunctionRef, Json } from "./protocol.js";
@@ -41,6 +43,10 @@ export declare function createClient(options: ClientOptions): {
     query: <I, O>(ref: FunctionRef<I, O>, args: I) => Promise<O>;
     mutation: <I, O>(ref: FunctionRef<I, O>, args: I) => Promise<O>;
     action: <I, O>(ref: FunctionRef<I, O>, args: I) => Promise<O>;
+    codexEvents<I>(ref: FunctionRef<I, CodexSubscription>, args: I, streamOptions?: {
+        signal?: AbortSignal;
+        after?: number;
+    }): AsyncGenerator<import("./codex-stream.js").CodexEvent, void, any>;
     /** One subscription delivers the initial snapshot and subsequent updates. */
     onUpdate<I, O>(ref: FunctionRef<I, O>, args: I, next: (value: O) => void, error?: (error: FlareError) => void): () => void;
     /** Call on login/logout/account switch; never reuse cached values across identities. */

package/dist/sdk/client.js

@@ -1,3 +1,4 @@
+import { readCodexEvents } from "./codex-stream.js";
 import { readBody } from "./http.js";
 import {
   assertPath,
@@ -279,6 +280,34 @@ export function createClient(options) {
     query: invoke("query"),
     mutation: invoke("mutation"),
     action: invoke("action"),
+    async* codexEvents(ref, args, streamOptions = {}) {
+      ensureOpen();
+      assertPath(ref.path);
+      const controller = new AbortController;
+      const abort = () => controller.abort();
+      cleanups.add(abort);
+      streamOptions.signal?.addEventListener("abort", abort, { once: true });
+      if (streamOptions.signal?.aborted)
+        abort();
+      try {
+        yield* readCodexEvents({
+          url: endpoint("/v1/codex/events"),
+          ref,
+          args,
+          after: streamOptions.after,
+          transport,
+          signal: controller.signal,
+          token: async () => {
+            ensureOpen();
+            return await options.getToken?.() ?? null;
+          }
+        });
+      } finally {
+        abort();
+        cleanups.delete(abort);
+        streamOptions.signal?.removeEventListener("abort", abort);
+      }
+    },
     onUpdate(ref, args, next, error) {
       const observer = { next, error };
       ensureOpen();

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,
@@ -359,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-stream.d.ts

@@ -0,0 +1,28 @@
+import { type FunctionRef } from "./protocol.js";
+import type { CodexTask } from "./codex.js";
+export type CodexSubscription = {
+    type: "codex-events";
+    id: string;
+};
+export type CodexEvent = {
+    type: "task";
+    task: CodexTask;
+} | {
+    type: "status" | "text" | "output" | "item" | "truncated";
+    seq: number;
+    at: number;
+    itemId?: string;
+    text?: string;
+    kind?: string;
+    state?: string;
+    exitCode?: number | null;
+};
+export declare function readCodexEvents<I>(options: {
+    url: string;
+    ref: FunctionRef<I, CodexSubscription>;
+    args: I;
+    token: () => Promise<string | null>;
+    transport: typeof fetch;
+    signal: AbortSignal;
+    after?: number;
+}): AsyncGenerator<CodexEvent>;

package/dist/sdk/codex-stream.js

@@ -0,0 +1,147 @@
+import {
+  FlareError,
+  boundedJson,
+  LIMITS
+} from "./protocol.js";
+import { readBody } from "./http.js";
+export async function* readCodexEvents(options) {
+  if (options.ref.kind !== "query")
+    throw new FlareError("INVALID_KIND", "Stream authorization must be a read-only query");
+  let cursor = options.after ?? 0, failures = 0;
+  if (!Number.isSafeInteger(cursor) || cursor < 0 || cursor > 4096)
+    throw new FlareError("INVALID_ARGUMENT", "Invalid cursor");
+  const signal = options.signal;
+  while (!signal.aborted) {
+    let reader;
+    const connection = new AbortController;
+    const abort = () => connection.abort(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted)
+      abort();
+    let idle;
+    const touch = () => {
+      clearTimeout(idle);
+      idle = setTimeout(() => connection.abort(), 45000);
+    };
+    try {
+      touch();
+      const token = await options.token();
+      if (signal.aborted)
+        return;
+      const response = await options.transport(options.url, {
+        method: "POST",
+        redirect: "error",
+        signal: connection.signal,
+        headers: {
+          "Content-Type": "application/json",
+          ...token ? { Authorization: `Bearer ${token}` } : {}
+        },
+        body: boundedJson({
+          path: options.ref.path,
+          kind: "query",
+          args: options.args,
+          after: cursor
+        }, LIMITS.inputBytes)
+      });
+      if (!response.ok) {
+        const bytes = response.body ? await readBody(response.body, 8192, () => {
+          throw new FlareError("INVALID_RESPONSE", "Oversized error");
+        }) : new Uint8Array;
+        let code = `HTTP_${response.status}`;
+        try {
+          const value = JSON.parse(new TextDecoder().decode(bytes));
+          if (/^[A-Z][A-Z0-9_]{0,63}$/.test(value.error))
+            code = value.error;
+        } catch {}
+        throw new FlareError(code, "Event subscription failed");
+      }
+      if (!response.headers.get("content-type")?.startsWith("text/event-stream") || !response.body)
+        throw new FlareError("INVALID_RESPONSE", "Expected SSE");
+      reader = response.body.getReader();
+      const decoder = new TextDecoder("utf-8", { fatal: true });
+      let pending = "", total = 0;
+      while (!signal.aborted) {
+        const next = await reader.read();
+        if (next.done)
+          break;
+        touch();
+        total += next.value.byteLength;
+        if (total > 1048576)
+          throw new FlareError("INVALID_RESPONSE", "Stream exceeds bound");
+        pending += decoder.decode(next.value, { stream: true });
+        let end;
+        while ((end = pending.indexOf(`
+
+`)) >= 0) {
+          const frame = pending.slice(0, end);
+          pending = pending.slice(end + 2);
+          if (frame.length > 524288)
+            throw new FlareError("INVALID_RESPONSE", "Oversized event");
+          let name = "", data = "", id = "";
+          for (const line of frame.split(`
+`)) {
+            if (line.startsWith("event:"))
+              name = line.slice(6).trim();
+            if (line.startsWith("data:"))
+              data += line.slice(5).trimStart();
+            if (line.startsWith("id:"))
+              id = line.slice(3).trim();
+          }
+          if (!data)
+            continue;
+          if (name === "reconnect")
+            continue;
+          const value = JSON.parse(data);
+          if (name === "task") {
+            if (!value || typeof value.id !== "string" || !["succeeded", "failed", "cancelled", "interrupted"].includes(value.state))
+              throw new FlareError("INVALID_RESPONSE", "Invalid task");
+            yield { type: "task", task: value };
+            return;
+          }
+          if (name !== "progress" || !Number.isSafeInteger(value.seq) || String(value.seq) !== id || value.seq > 4096 || !["status", "text", "output", "item", "truncated"].includes(value.type))
+            throw new FlareError("INVALID_RESPONSE", "Invalid event");
+          if (value.seq <= cursor)
+            continue;
+          if (value.seq !== cursor + 1)
+            throw new FlareError("CODEX_EVENT_GAP", "Event gap");
+          cursor = value.seq;
+          failures = 0;
+          yield value;
+        }
+        if (pending.length > 524288)
+          throw new FlareError("INVALID_RESPONSE", "Oversized frame");
+      }
+    } catch (error) {
+      if (signal.aborted)
+        return;
+      const code = error instanceof FlareError ? error.code : "";
+      if (code && ![
+        "HTTP_429",
+        "HTTP_500",
+        "HTTP_502",
+        "HTTP_503",
+        "HTTP_504",
+        "CODEX_UNAVAILABLE"
+      ].includes(code))
+        throw error;
+      if (++failures > 5)
+        throw new FlareError("CODEX_STREAM_INTERRUPTED", "Reconnect failed; task continues independently");
+    } finally {
+      clearTimeout(idle);
+      signal.removeEventListener("abort", abort);
+      connection.abort();
+      await reader?.cancel().catch(() => {});
+    }
+    if (signal.aborted)
+      return;
+    await new Promise((resolve) => {
+      const done = () => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", done);
+        resolve();
+      };
+      const timer = setTimeout(done, Math.min(5000, 500 * 2 ** failures));
+      signal.addEventListener("abort", done, { once: true });
+    });
+  }
+}

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/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/react.d.ts

@@ -9,6 +9,10 @@ export declare function FlareProvider({ client, children, }: {
     query: <I, O>(ref: FunctionRef<I, O>, args: I) => Promise<O>;
     mutation: <I, O>(ref: FunctionRef<I, O>, args: I) => Promise<O>;
     action: <I, O>(ref: FunctionRef<I, O>, args: I) => Promise<O>;
+    codexEvents<I>(ref: FunctionRef<I, import("./codex-stream.js").CodexSubscription>, args: I, streamOptions?: {
+        signal?: AbortSignal;
+        after?: number;
+    }): AsyncGenerator<import("./codex-stream.js").CodexEvent, void, any>;
     onUpdate<I, O>(ref: FunctionRef<I, O>, args: I, next: (value: O) => void, error?: (error: FlareError) => void): () => void;
     refreshAuth(): void;
     dispose(): void;

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

package/dist/sdk/server.d.ts

@@ -1,3 +1,8 @@
+export type { CodexSubscription } from "./codex-stream.js";
+import type { CodexContext } from "./codex.js";
+export type { CodexContext, CodexTask, CodexTaskInput } from "./codex.js";
+import type { SearchContext } from "./search.js";
+export type { SearchContext, SearchHit, SearchState } from "./search.js";
 export { z } from "zod";
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { Validator, Schema } from "./schema.js";
@@ -5,7 +10,7 @@ import type { ReadDatabase, WriteDatabase } from "./database.js";
 export { defineSchema, defineTable, schemaContract } from "./schema.js";
 export type { Validator, Schema, Doc, Value, Input, SchemaContract, } from "./schema.js";
 export type { ReadDatabase, WriteDatabase, Page } from "./database.js";
-import { type Auth, type FunctionKind, type FunctionRef, type Json, type Manifest } from "./protocol.js";
+import { type McpTool, type Auth, type FunctionKind, type FunctionRef, type Json, type Manifest } from "./protocol.js";
 export interface QueryContext<S extends Schema = Schema> {
     readonly db: ReadDatabase<S>;
     readonly auth: Auth | null;
@@ -21,6 +26,8 @@ export interface MutationContext<S extends Schema = Schema> {
     };
 }
 export interface ActionContext {
+    readonly codex: CodexContext;
+    readonly search: SearchContext;
     readonly auth: Auth | null;
     runQuery<I, O>(ref: FunctionRef<I, O>, args: I): Promise<O>;
     runMutation<I, O>(ref: FunctionRef<I, O>, args: I): Promise<O>;
@@ -86,6 +93,7 @@ export interface ActionContext {
 type Context<K extends FunctionKind, S extends Schema = Schema> = K extends "action" ? ActionContext : K extends "mutation" ? MutationContext<S> : QueryContext<S>;
 export interface Definition<K extends FunctionKind = FunctionKind, I = any, O = any, S extends Schema = Schema> {
     readonly kind: K;
+    readonly mcp?: McpTool;
     readonly input: Validator<any, I>;
     readonly output: Validator<O, any>;
     readonly auth: "required" | "public" | "internal";
@@ -95,18 +103,21 @@ export declare const query: <IV extends Validator, OV extends Validator>(options
     input: IV;
     output: OV;
     auth?: "required" | "public" | "internal";
+    mcp?: McpTool;
     handler: (ctx: QueryContext<Schema>, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
 }) => Definition<"query", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, Schema>;
 export declare const mutation: <IV extends Validator, OV extends Validator>(options: {
     input: IV;
     output: OV;
     auth?: "required" | "public" | "internal";
+    mcp?: McpTool;
     handler: (ctx: MutationContext<Schema>, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
 }) => Definition<"mutation", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, Schema>;
 export declare const action: <IV extends Validator, OV extends Validator>(options: {
     input: IV;
     output: OV;
     auth?: "required" | "public" | "internal";
+    mcp?: McpTool;
     handler: (ctx: ActionContext, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
 }) => Definition<"action", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, Schema>;
 export declare function createFunctions<S extends Schema>(): {
@@ -114,18 +125,21 @@ export declare function createFunctions<S extends Schema>(): {
         input: IV;
         output: OV;
         auth?: "required" | "public" | "internal";
+        mcp?: McpTool;
         handler: (ctx: QueryContext<S>, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
     }) => Definition<"query", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, S>;
     mutation: <IV extends Validator, OV extends Validator>(options: {
         input: IV;
         output: OV;
         auth?: "required" | "public" | "internal";
+        mcp?: McpTool;
         handler: (ctx: MutationContext<S>, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
     }) => Definition<"mutation", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, S>;
     action: <IV extends Validator, OV extends Validator>(options: {
         input: IV;
         output: OV;
         auth?: "required" | "public" | "internal";
+        mcp?: McpTool;
         handler: (ctx: ActionContext, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
     }) => Definition<"action", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, Schema>;
 };

package/dist/sdk/server.js

@@ -3,6 +3,7 @@ import { schemaContract } from "./schema.js";
 export { defineSchema, defineTable, schemaContract } from "./schema.js";
 import {
   assertPath,
+  assertMcpTools,
   boundedJson,
   LIMITS,
   FlareError
@@ -63,8 +64,15 @@ export function manifest(app) {
     });
     if (!input || !output)
       throw new FlareError("INVALID_CONTRACT", `${path} requires JSON Schema converters`);
-    functions[path] = { kind: fn.kind, auth: fn.auth, input, output };
+    functions[path] = {
+      kind: fn.kind,
+      auth: fn.auth,
+      input,
+      output,
+      ...fn.mcp !== undefined ? { mcp: fn.mcp } : {}
+    };
   }
+  assertMcpTools(functions);
   boundedJson(functions, 1048576);
   return { protocol: 1, runtimeAbi: 4, functions };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auersperg/flare",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "license": "MIT",
   "type": "module",
   "description": "Flare client, server declarations and development CLI",

package/dist/platform/dashboard/_astro/client.4z54xJ_z.js

@@ -1 +0,0 @@
-async function e(e,t,n){let r=e.getReader(),i=[],a=0;try{for(;;){let{done:e,value:o}=await r.read();if(e)break;a+=o.byteLength,a>t&&n(),i.push(o)}}finally{await r.cancel().catch(()=>{})}if(i.length===1)return i[0];let o=new Uint8Array(a),s=0;for(let e of i)o.set(e,s),s+=e.byteLength;return o}var t=Object.freeze({inputBytes:65536,outputBytes:262144,frameBytes:8192,subscriptions:64,fileBytes:10485760}),n=class extends Error{code;ambiguous;constructor(e,t,n=!1){super(t),this.code=e,this.ambiguous=n,this.name=`FlareError`}};function r(e){if(e.length>256||!/^[A-Za-z][A-Za-z0-9_]*(\/[A-Za-z][A-Za-z0-9_]*)*$/.test(e)||e.split(`/`).some(e=>[`__proto__`,`prototype`,`constructor`].includes(e)))throw new n(`INVALID_PATH`,`Invalid function path`)}function i(e,t){return r(e),Object.freeze({path:e,kind:t})}function a(e){let t=new Set;function r(e,i){if(i>40)throw new n(`INVALID_JSON`,`JSON nesting limit exceeded`);if(e===null||typeof e==`string`||typeof e==`boolean`||typeof e==`number`&&Number.isFinite(e))return e;if(typeof e!=`object`||!e||t.has(e))throw new n(`INVALID_JSON`,`Expected lossless JSON`);if(!Array.isArray(e)&&Object.getPrototypeOf(e)!==Object.prototype&&Object.getPrototypeOf(e)!==null)throw new n(`INVALID_JSON`,`Expected plain JSON object`);if(Object.getOwnPropertySymbols(e).length)throw new n(`INVALID_JSON`,`Symbol keys are unsupported`);t.add(e);let a;if(Array.isArray(e))a=Array.from(e,e=>r(e,i+1));else{let t=Object.create(null);for(let a of Object.keys(e).sort()){let o=Object.getOwnPropertyDescriptor(e,a);if(!(`value`in o))throw new n(`INVALID_JSON`,`Getters are unsupported`);t[a]=r(o.value,i+1)}a=t}return t.delete(e),a}return JSON.stringify(r(e,0))}function o(e,t){let r=a(e);if(new TextEncoder().encode(r).byteLength>t)throw new n(`TOO_LARGE`,`JSON payload exceeds limit`);return r}function s(e){if(e.size>t.fileBytes)throw new n(`TOO_LARGE`,`Maximum file size: 10 MiB`);if(!e.name||e.name.length>120||/[\x00-\x1f\x7f/\\]/.test(e.name))throw new n(`INVALID_INPUT`,`File name must be 1–120 characters, without path separators`);return{name:e.name,size:e.size,type:[`text/plain`,`image/png`,`image/jpeg`,`image/webp`,`application/pdf`].includes(e.type)?e.type:`application/octet-stream`}}async function c(r,i,a={}){if(i.size>t.fileBytes)throw new n(`TOO_LARGE`,`Maximum file size: 10 MiB`);let o=new URL(r.url);if(o.username||o.password||o.protocol!==`https:`&&!(o.protocol===`http:`&&[`localhost`,`127.0.0.1`,`[::1]`].includes(o.hostname)))throw new n(`INVALID_URL`,`Expected secure upload URL`);let s;try{s=await(a.fetch??globalThis.fetch)(o.href,{method:`POST`,body:i,redirect:`error`,credentials:`omit`,signal:AbortSignal.any([...a.signal?[a.signal]:[],AbortSignal.timeout(a.timeoutMs??12e4)])})}catch{throw new n(`UPLOAD_UNKNOWN`,`Connection interrupted or upload timed out; refresh the file list before trying again`,!0)}let c=s.body?await e(s.body,t.outputBytes,()=>{throw Error(`Upload response exceeds limit`)}).then(e=>JSON.parse(new TextDecoder(`utf-8`,{fatal:!0}).decode(e))).catch(()=>null):null;if(!s.ok){let e=c&&typeof c==`object`&&`error`in c&&typeof c.error==`string`?c.error:`HTTP_${s.status}`;throw new n(e,`Upload failed: ${e}`,s.status>=500)}if(!c||typeof c!=`object`||!(`id`in c)||typeof c.id!=`string`)throw new n(`INVALID_RESPONSE`,`Upload outcome is unknown; refresh the file list before uploading again`,!0);return{id:c.id}}var l=new Set([`UNAUTHORIZED`,`AUTH_EXPIRED`,`FORBIDDEN`,`AUTH_DISABLED`,`HTTP_401`,`HTTP_403`]);function u(i){let s=new URL(i.url);if(!/^https?:$/.test(s.protocol)||s.username||s.password||s.search||s.hash)throw new n(`INVALID_URL`,`Expected backend HTTP URL`);if(s.protocol===`http:`&&![`localhost`,`127.0.0.1`,`[::1]`].includes(s.hostname))throw new n(`INVALID_URL`,`Remote backends require HTTPS`);s.pathname=s.pathname.replace(/\/$/,``);let c=i.fetch??globalThis.fetch;if(!c)throw new n(`TRANSPORT_UNAVAILABLE`,`Provide a fetch implementation`);let u=new Map,d=!1,f,p=!1,m=0,h=0,g=0,_,v=new Set,y=e=>`${s.href.replace(/\/$/,``)}${e}`,b=(e,t,n)=>{for(let r of e.observers)try{r[t]?.(t===`next`?JSON.parse(n):n)}catch{}};function x(){if(d)throw new n(`DISPOSED`,`Client is disposed`)}async function S(r,a,s){x();let l=o(a,t.inputBytes),u;try{u=await i.getToken?.()??null}catch{throw new n(`AUTH_UNAVAILABLE`,`Cannot obtain access token`)}x();let d=new AbortController,f=setTimeout(()=>d.abort(),i.requestTimeoutMs??3e4);try{let i=await c(y(r),{method:`POST`,headers:{"Content-Type":`application/json`,...u?{Authorization:`Bearer ${u}`}:{}},body:l,signal:d.signal,redirect:`error`});if(!i.body)throw new n(`INVALID_RESPONSE`,`Missing response body`,s);let a=await e(i.body,t.outputBytes,()=>{throw new n(`INVALID_RESPONSE`,`Response exceeds limit`,s)}),f;try{f=JSON.parse(new TextDecoder(`utf-8`,{fatal:!0}).decode(a))}catch(e){throw i.ok?e:new n(`HTTP_${i.status}`,`Backend request failed`,s&&i.status>=500)}if(!i.ok)throw new n(f&&typeof f==`object`&&`error`in f&&typeof f.error==`string`&&/^[A-Z][A-Z0-9_]{0,63}$/.test(f.error)?f.error:`HTTP_${i.status}`,`Backend request failed`,s&&i.status>=500);if(!f||typeof f!=`object`||!(`result`in f))throw new n(`INVALID_RESPONSE`,`Invalid protocol envelope`,s);return o(f.result,t.outputBytes),f.result}catch(e){throw e instanceof n?e:e instanceof SyntaxError?new n(`INVALID_RESPONSE`,`Invalid JSON response`,s):new n(`TRANSPORT_ERROR`,s?`Write outcome is unknown; do not replay automatically`:`Backend request interrupted`,s)}finally{clearTimeout(f)}}function C(e){f?.send(o(e,t.frameBytes))}function w(e){C({type:`subscribe`,id:e.id,path:e.ref.path,args:e.args})}function T(){if(d||!u.size||_)return;let e=Math.min(3e4,250*2**Math.min(m++,7));_=setTimeout(()=>{_=void 0,E()},e)}async function E(){if(d||p||f||!u.size)return;p=!0;let e=++h;try{let r=await S(`/v1/live/ticket`,{},!1);if(d||e!==h||!u.size)return;if(!r||typeof r.ticket!=`string`||r.ticket.length>1024)throw new n(`INVALID_RESPONSE`,`Invalid live ticket`);let a=new URL(y(`/v1/live`));a.protocol=a.protocol===`https:`?`wss:`:`ws:`,a.searchParams.set(`ticket`,r.ticket);let s=i.createWebSocket?i.createWebSocket(a.href):new globalThis.WebSocket(a.href);f=s;let c=()=>{if(!(f!==s||d)){m=0;for(let e of u.values())e.revision=-1,e.snapshot=void 0,e.terminal||w(e)}},p=e=>{if(!(f!==s||d))try{if(typeof e.data!=`string`||new TextEncoder().encode(e.data).byteLength>t.outputBytes+1024)throw Error(`Invalid frame`);let r=JSON.parse(e.data);if(r.type===`ready`)return;let i=[...u.values()].find(e=>e.id===r.id);if(!i||i.terminal)return;if(r.type===`error`){i.terminal=!0,l.has(r.code)&&(i.snapshot=void 0),b(i,`error`,new n(typeof r.code==`string`?r.code:`LIVE_ERROR`,`Live subscription failed`));return}if(r.type!==`snapshot`||!Number.isSafeInteger(r.revision)||r.revision<0||!(`result`in r))throw Error(`Invalid snapshot`);let a=o(r.result,t.outputBytes);if(r.revision>i.revision){let e=i.snapshot!==a;i.revision=r.revision,i.snapshot=a,e&&b(i,`next`,i.snapshot)}C({type:`ack`,id:i.id,revision:i.revision})}catch{s.close(1002,`Invalid protocol frame`)}},g=e=>{if(x(),f===s){f=void 0;for(let t of u.values())e.code===1008&&(t.snapshot=void 0,t.revision=-1),t.terminal||b(t,`error`,new n(e.code===1008?`AUTH_EXPIRED`:`LIVE_DISCONNECTED`,`Live reconnecting; next snapshot will be current`));T()}},_=()=>s.close(),x=()=>{s.removeEventListener(`open`,c),s.removeEventListener(`message`,p),s.removeEventListener(`close`,g),s.removeEventListener(`error`,_),v.delete(x)};v.add(x),s.addEventListener(`open`,c),s.addEventListener(`message`,p),s.addEventListener(`close`,g),s.addEventListener(`error`,_)}catch(t){if(d||e!==h)return;for(let e of u.values())t instanceof n&&l.has(t.code)&&(e.snapshot=void 0,e.revision=-1),b(e,`error`,t instanceof n?t:new n(`LIVE_UNAVAILABLE`,`Live connection failed`));T()}finally{p=!1,!d&&e!==h&&!f&&u.size&&T()}}function D(e){return async(t,i)=>{if(r(t.path),t.kind!==e)throw new n(`INVALID_KIND`,`Expected a ${e} function`);return S(`/v1/call`,{path:t.path,kind:t.kind,args:i},t.kind===`mutation`||t.kind===`action`)}}return{query:D(`query`),mutation:D(`mutation`),action:D(`action`),onUpdate(e,i,s,c){let l={next:s,error:c};if(x(),r(e.path),e.kind!==`query`)throw new n(`INVALID_KIND`,`Only queries are subscribable`);o({type:`subscribe`,id:`subscription-9999999999`,path:e.path,args:i},t.frameBytes);let d=a({path:e.path,args:i}),p=u.get(d);if(!p){if(u.size>=t.subscriptions)throw new n(`TOO_MANY_SUBSCRIPTIONS`,`Subscription limit exceeded`);p={id:`subscription-${++g}`,ref:e,args:JSON.parse(a(i)),observers:new Set,revision:-1,terminal:!1},u.set(d,p),f?.readyState===1&&w(p)}let m={next:l.next,error:l.error};p.observers.add(m),p.snapshot!==void 0&&b({...p,observers:new Set([l])},`next`,p.snapshot),E();let y=!1;return()=>{if(!y&&(y=!0,p.observers.delete(m),p.observers.size||(u.delete(d),f?.readyState===1&&C({type:`unsubscribe`,id:p.id})),!u.size)){++h,_&&clearTimeout(_),_=void 0;let e=f;f=void 0;for(let e of[...v])e();e?.close(1e3,`No subscriptions`)}}},refreshAuth(){x(),++h,_&&clearTimeout(_),_=void 0;for(let e of[...v])e();let e=f;f=void 0,e?.close(1e3,`Authorization changed`);for(let e of u.values())e.snapshot=void 0,e.revision=-1,e.terminal=!1,b(e,`error`,new n(`AUTH_CHANGED`,`Authorization changed; cached value invalidated`));E()},dispose(){if(!d){d=!0,++h,_&&clearTimeout(_),_=void 0;for(let e of[...v])e();u.clear(),f?.close(1e3,`Disposed`),f=void 0}}}}export{i,s as n,c as r,u as t};