@byteplus-iga-pages/agent 0.0.0-stage → 1.0.4

package/dist/esm/417.js

@@ -0,0 +1,704 @@
+import { DataPlaneError, randomUUID, DataPlaneCredentialProvider, validateDataPlaneRootUrl, createAuthenticatedSupabaseClient, fetchDataPlaneCredentials } from "./128.js";
+class StoreError extends Error {
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.error?.message ?? this.message,
+            ...void 0 !== this.status ? {
+                status: this.status
+            } : {},
+            ...void 0 !== this.error ? {
+                error: this.error
+            } : {}
+        };
+    }
+    constructor(code, message, options = {}){
+        super(options.error?.message ?? message);
+        this.name = "StoreError";
+        this.code = code;
+        if (null !== options.error) this.error = options.error ?? {
+            message
+        };
+        if (Number.isInteger(options.status) && options.status >= 0 && options.status <= 599) this.status = options.status;
+    }
+}
+function storeCodeForStatus(status) {
+    const codes = {
+        0: "NetworkError",
+        400: "BadRequest",
+        401: "Unauthorized",
+        402: "PaymentRequired",
+        403: "Forbidden",
+        404: "NotFound",
+        405: "MethodNotAllowed",
+        406: "NotAcceptable",
+        408: "RequestTimeout",
+        409: "Conflict",
+        410: "Gone",
+        411: "LengthRequired",
+        412: "PreconditionFailed",
+        413: "PayloadTooLarge",
+        414: "URITooLong",
+        415: "UnsupportedMediaType",
+        416: "RangeNotSatisfiable",
+        417: "ExpectationFailed",
+        418: "ImATeapot",
+        422: "UnprocessableEntity",
+        423: "Locked",
+        424: "FailedDependency",
+        425: "TooEarly",
+        426: "UpgradeRequired",
+        428: "PreconditionRequired",
+        429: "TooManyRequests",
+        431: "RequestHeaderFieldsTooLarge",
+        451: "UnavailableForLegalReasons",
+        500: "InternalServerError",
+        501: "NotImplemented",
+        502: "BadGateway",
+        503: "ServiceUnavailable",
+        504: "GatewayTimeout",
+        505: "HTTPVersionNotSupported"
+    };
+    return codes[status] ?? "UnknownError";
+}
+function credential_error_toStoreCredentialError(error) {
+    if (error instanceof StoreError) return error;
+    const source = error instanceof DataPlaneError ? error : void 0;
+    const codes = {
+        authentication_failed: "Unauthorized",
+        timeout: "TimeoutError",
+        aborted: "AbortError",
+        rate_limited: "TooManyRequests",
+        unavailable: "ServiceUnavailable",
+        unknown: "UnknownError"
+    };
+    let type = "unavailable";
+    if (source) {
+        if ("authentication_failed" === source.failureKind || "unauthenticated" === source.code || "permission_denied" === source.code) type = "authentication_failed";
+        else if ("timeout" === source.failureKind) type = "timeout";
+        else if ("aborted" === source.code) type = "aborted";
+        else if ("rate_limited" === source.code) type = "rate_limited";
+        else if ("unavailable" !== source.code) type = "unknown";
+    }
+    const messages = {
+        authentication_failed: "Store authentication failed",
+        timeout: "Store authentication request timed out",
+        aborted: "Store request was cancelled",
+        rate_limited: "Store authentication is receiving too many requests",
+        unavailable: "Store authentication is temporarily unavailable",
+        unknown: "Store returned invalid credentials"
+    };
+    return new StoreError(codes[type], messages[type], {
+        status: source?.status,
+        error: null
+    });
+}
+function toDataPlaneError(error) {
+    if (error instanceof DataPlaneError) return error;
+    if (error instanceof StoreError) return new DataPlaneError("Unauthorized" === error.code ? "unauthenticated" : "TooManyRequests" === error.code ? "rate_limited" : "AbortError" === error.code ? "aborted" : "ServiceUnavailable" === error.code || "TimeoutError" === error.code ? "unavailable" : "internal", error.message, {
+        operation: "data-plane.authenticate",
+        status: error.status,
+        ..."TimeoutError" === error.code ? {
+            failureKind: "timeout"
+        } : {}
+    });
+    return new DataPlaneError("unavailable", "Data plane authentication is temporarily unavailable", {
+        operation: "data-plane.authenticate",
+        retryable: true
+    });
+}
+class credential_provider_StoreCredentialProvider {
+    async getValidCredentials() {
+        try {
+            return await this.delegate.getValidCredentials();
+        } catch (error) {
+            throw credential_error_toStoreCredentialError(error);
+        }
+    }
+    async getProjectId() {
+        try {
+            return await this.delegate.getProjectId();
+        } catch (error) {
+            throw credential_error_toStoreCredentialError(error);
+        }
+    }
+    invalidate(jwt) {
+        this.delegate.invalidate(jwt);
+    }
+    constructor(options){
+        this.delegate = new DataPlaneCredentialProvider({
+            now: options.now,
+            fetchCredentials: async ()=>{
+                try {
+                    return await options.fetchCredentials();
+                } catch (error) {
+                    throw toDataPlaneError(error);
+                }
+            }
+        });
+    }
+}
+class StoreCredentialProviderCache {
+    get(scope) {
+        if (!scope.environment || !scope.projectId) throw new StoreError("ServiceUnavailable", "Store credentials are unavailable");
+        let projects = this.providers.get(scope.environment);
+        if (!projects) {
+            projects = new Map();
+            this.providers.set(scope.environment, projects);
+        }
+        let provider = projects.get(scope.projectId);
+        if (!provider) {
+            provider = this.createProvider(Object.freeze({
+                ...scope
+            }));
+            projects.set(scope.projectId, provider);
+        }
+        return provider;
+    }
+    clear(scope) {
+        if (!scope) return void this.providers.clear();
+        const projects = this.providers.get(scope.environment);
+        projects?.delete(scope.projectId);
+        if (projects?.size === 0) this.providers.delete(scope.environment);
+    }
+    constructor(options){
+        this.providers = new Map();
+        this.createProvider = options.createProvider;
+    }
+}
+function invalidJson(field) {
+    return new StoreError("BadRequest", `${field} must contain only JSON-compatible values`);
+}
+function cloneJsonValueInternal(value, field, ancestors) {
+    if (null === value || "string" == typeof value || "boolean" == typeof value) return value;
+    if ("number" == typeof value) {
+        if (!Number.isFinite(value)) throw invalidJson(field);
+        return value;
+    }
+    if (Array.isArray(value)) {
+        if (ancestors.has(value)) throw invalidJson(field);
+        ancestors.add(value);
+        const cloned = [];
+        for(let index = 0; index < value.length; index += 1){
+            if (!(index in value)) throw invalidJson(field);
+            cloned.push(cloneJsonValueInternal(value[index], field, ancestors));
+        }
+        ancestors.delete(value);
+        return cloned;
+    }
+    if ("object" == typeof value) {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && null !== prototype) throw invalidJson(field);
+        if (ancestors.has(value)) throw invalidJson(field);
+        ancestors.add(value);
+        const cloned = {};
+        for (const [key, child] of Object.entries(value))Object.defineProperty(cloned, key, {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: cloneJsonValueInternal(child, field, ancestors)
+        });
+        ancestors.delete(value);
+        return cloned;
+    }
+    throw invalidJson(field);
+}
+function cloneJsonValue(value, field) {
+    return cloneJsonValueInternal(value, field, new WeakSet());
+}
+function cloneJsonObject(value, field) {
+    const cloned = cloneJsonValue(value, field);
+    if (null === cloned || Array.isArray(cloned) || "object" != typeof cloned) throw new StoreError("BadRequest", `${field} must be a JSON object`);
+    return cloned;
+}
+function materializeAppendMessages(messages, generateUuid = randomUUID) {
+    if (!Array.isArray(messages) || messages.length < 1 || messages.length > 100) throw new StoreError("BadRequest", "appendMessages requires between 1 and 100 messages");
+    const ids = new Set();
+    return messages.map((message, index)=>{
+        if (null === message || "object" != typeof message) throw new StoreError("BadRequest", `messages[${index}] must be an object`);
+        if (void 0 !== message.role && null !== message.role && "string" != typeof message.role) throw new StoreError("BadRequest", `messages[${index}].role must be a string or null`);
+        if (void 0 !== message.type && null !== message.type && "string" != typeof message.type) throw new StoreError("BadRequest", `messages[${index}].type must be a string or null`);
+        if (void 0 !== message.messageId && "string" != typeof message.messageId) throw new StoreError("BadRequest", `messages[${index}].messageId must be a string`);
+        const messageId = message.messageId ?? generateUuid();
+        if (ids.has(messageId)) throw new StoreError("BadRequest", "appendMessages contains duplicate messageId values");
+        ids.add(messageId);
+        return Object.freeze({
+            messageId,
+            role: message.role ?? null,
+            type: message.type ?? null,
+            payload: cloneJsonValue(message.payload, `messages[${index}].payload`),
+            metadata: void 0 === message.metadata ? {} : cloneJsonObject(message.metadata, `messages[${index}].metadata`)
+        });
+    });
+}
+const DEFAULT_STORE_PAGE_LIMIT = 50;
+const MAX_STORE_PAGE_LIMIT = 100;
+const TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
+function validationError() {
+    return new StoreError("BadRequest", "Store cursor is invalid");
+}
+function encode(value) {
+    return Buffer.from(JSON.stringify(value)).toString("base64url");
+}
+function decode(value) {
+    try {
+        return JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    } catch  {
+        throw validationError();
+    }
+}
+function isObject(value) {
+    return null !== value && "object" == typeof value && !Array.isArray(value);
+}
+function isTimestamp(value) {
+    return "string" == typeof value && TIMESTAMP_PATTERN.test(value) && Number.isFinite(Date.parse(value));
+}
+function isConversationId(value) {
+    return "string" == typeof value && value.length > 0 && Buffer.byteLength(value, "utf8") <= 256;
+}
+function isSequence(value) {
+    return "string" == typeof value && /^(0|[1-9]\d*)$/.test(value);
+}
+function normalizeStorePageLimit(limit) {
+    if (void 0 === limit) return DEFAULT_STORE_PAGE_LIMIT;
+    if (!Number.isInteger(limit) || limit < 1 || limit > MAX_STORE_PAGE_LIMIT) throw new StoreError("BadRequest", `Store page limit must be an integer from 1 to ${MAX_STORE_PAGE_LIMIT}`);
+    return limit;
+}
+function encodeConversationCursor(cursor) {
+    return encode({
+        version: 1,
+        kind: "conversations",
+        ...cursor
+    });
+}
+function decodeConversationCursor(value) {
+    const cursor = decode(value);
+    if (!isObject(cursor) || 1 !== cursor.version || "conversations" !== cursor.kind || !isTimestamp(cursor.updatedAt) || !isConversationId(cursor.conversationId)) throw validationError();
+    return {
+        updatedAt: cursor.updatedAt,
+        conversationId: cursor.conversationId
+    };
+}
+function encodeMessageCursor(cursor) {
+    return encode({
+        version: 1,
+        kind: "messages",
+        ...cursor
+    });
+}
+function decodeMessageCursor(value, expected) {
+    const cursor = decode(value);
+    if (!isObject(cursor) || 1 !== cursor.version || "messages" !== cursor.kind || !isConversationId(cursor.conversationId) || cursor.conversationId !== expected.conversationId || cursor.order !== expected.order || !isSequence(cursor.snapshotSeq) || !isSequence(cursor.lastSeq)) throw validationError();
+    return {
+        conversationId: cursor.conversationId,
+        order: expected.order,
+        snapshotSeq: cursor.snapshotSeq,
+        lastSeq: cursor.lastSeq
+    };
+}
+const SEQUENCE_PATTERN = /^(0|[1-9]\d*)$/;
+const CONVERSATION_COLUMNS = "conversation_id,metadata,created_at,updated_at";
+const MESSAGE_COLUMNS = "event_id,conversation_id,seq_text,role,event_type,payload,metadata,created_at,updated_at";
+const DEFAULT_STORE_RPC_NAMES = Object.freeze({
+    appendMessages: "append_messages",
+    updateConversation: "update_conversation",
+    deleteConversation: "delete_conversation",
+    deleteMessage: "delete_event",
+    clearMessages: "clear_messages"
+});
+function invalid(message) {
+    throw new StoreError("BadRequest", message);
+}
+function internal() {
+    throw new StoreError("UnknownError", "Store returned invalid data");
+}
+function requireObject(value, field) {
+    if (null === value || "object" != typeof value || Array.isArray(value)) invalid(`${field} must be an object`);
+    return value;
+}
+function requireConversationId(value) {
+    if ("string" != typeof value || 0 === value.length) invalid("conversationId must be a non-empty string");
+    if (Buffer.byteLength(value, "utf8") > 256) invalid("conversationId must not exceed 256 UTF-8 bytes");
+    return value;
+}
+function requireMessageId(value) {
+    if ("string" != typeof value || "" === value) invalid("messageId must be a non-empty string");
+    return value;
+}
+function requireTimestamp(value) {
+    if ("string" != typeof value || "" === value || !Number.isFinite(Date.parse(value))) internal();
+    return value;
+}
+function requireNextSequence(value) {
+    if ("string" == typeof value && SEQUENCE_PATTERN.test(value)) return value;
+    if ("number" == typeof value && Number.isSafeInteger(value) && value >= 0) return String(value);
+    internal();
+}
+function mapConversation(value) {
+    const row = requireStoreRow(value);
+    if ("string" != typeof row.conversation_id) internal();
+    return {
+        conversationId: row.conversation_id,
+        metadata: readStoreJsonObject(row.metadata),
+        createdAt: requireTimestamp(row.created_at),
+        updatedAt: requireTimestamp(row.updated_at)
+    };
+}
+function mapMessage(value) {
+    const row = requireStoreRow(value);
+    if ("string" != typeof row.event_id || "string" != typeof row.conversation_id || "string" != typeof row.seq_text || !SEQUENCE_PATTERN.test(row.seq_text) || null !== row.role && "string" != typeof row.role || null !== row.event_type && "string" != typeof row.event_type) internal();
+    return {
+        messageId: row.event_id,
+        conversationId: row.conversation_id,
+        seq: row.seq_text,
+        role: row.role,
+        type: row.event_type,
+        payload: readStoreJsonValue(row.payload),
+        metadata: readStoreJsonObject(row.metadata),
+        createdAt: requireTimestamp(row.created_at),
+        updatedAt: requireTimestamp(row.updated_at)
+    };
+}
+function requireStoreRow(value) {
+    if (null === value || "object" != typeof value || Array.isArray(value)) internal();
+    return value;
+}
+function readStoreJsonValue(value) {
+    try {
+        return cloneJsonValue(value, "Store data");
+    } catch  {
+        internal();
+    }
+}
+function readStoreJsonObject(value) {
+    try {
+        return cloneJsonObject(value, "Store data");
+    } catch  {
+        internal();
+    }
+}
+function requireRows(value) {
+    if (!Array.isArray(value)) internal();
+    return value;
+}
+class SupabaseStore {
+    async createConversation(input = {}) {
+        const value = requireObject(input, "createConversation input");
+        const conversationId = void 0 === value.conversationId ? requireConversationId(this.generateUuid()) : requireConversationId(value.conversationId);
+        const metadata = void 0 === value.metadata ? {} : cloneJsonObject(value.metadata, "metadata");
+        const data = await this.execute((client)=>client.from("conversations").insert({
+                project_id: this.projectId,
+                conversation_id: conversationId,
+                metadata
+            }).select(CONVERSATION_COLUMNS).single(), {
+            operation: "store.createConversation",
+            retryNetwork: false
+        });
+        return mapConversation(data);
+    }
+    async getConversation(input) {
+        const value = requireObject(input, "getConversation input");
+        const conversationId = requireConversationId(value.conversationId);
+        const data = await this.execute((client)=>client.from("conversations").select(CONVERSATION_COLUMNS).eq("project_id", this.projectId).eq("conversation_id", conversationId).maybeSingle(), {
+            operation: "store.getConversation",
+            retryNetwork: true
+        });
+        return null === data ? null : mapConversation(data);
+    }
+    async listConversations(input = {}) {
+        const value = requireObject(input, "listConversations input");
+        const limit = normalizeStorePageLimit(value.limit);
+        const cursor = void 0 === value.cursor ? void 0 : "string" == typeof value.cursor ? decodeConversationCursor(value.cursor) : invalid("cursor must be a string");
+        const data = await this.execute((client)=>{
+            let query = client.from("conversations").select(CONVERSATION_COLUMNS).eq("project_id", this.projectId).order("updated_at", {
+                ascending: false
+            }).order("conversation_id", {
+                ascending: false
+            }).limit(limit + 1);
+            if (cursor) {
+                const quotedId = `"${cursor.conversationId.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+                query = query.or(`updated_at.lt.${cursor.updatedAt},and(updated_at.eq.${cursor.updatedAt},conversation_id.lt.${quotedId})`);
+            }
+            return query;
+        }, {
+            operation: "store.listConversations",
+            retryNetwork: true
+        });
+        const rows = requireRows(data);
+        const hasMore = rows.length > limit;
+        const items = rows.slice(0, limit).map(mapConversation);
+        const last = items.at(-1);
+        return {
+            items,
+            nextCursor: hasMore && last ? encodeConversationCursor({
+                updatedAt: last.updatedAt,
+                conversationId: last.conversationId
+            }) : null
+        };
+    }
+    async updateConversation(input) {
+        const value = requireObject(input, "updateConversation input");
+        const conversationId = requireConversationId(value.conversationId);
+        if (!("metadata" in value)) invalid("metadata is required");
+        const metadata = cloneJsonObject(value.metadata, "metadata");
+        const removalKeys = [];
+        for (const [key, item] of Object.entries(metadata))if (null === item) {
+            removalKeys.push(key);
+            delete metadata[key];
+        }
+        const data = await this.execute((client)=>client.rpc(this.rpcNames.updateConversation, {
+                p_project_id: this.projectId,
+                p_conversation_id: conversationId,
+                p_metadata: metadata,
+                p_remove_metadata_keys: removalKeys
+            }).maybeSingle(), {
+            operation: "store.updateConversation",
+            retryNetwork: false
+        });
+        if (null === data) throw new StoreError("NotFound", "Conversation was not found");
+        return mapConversation(data);
+    }
+    async deleteConversation(input) {
+        const value = requireObject(input, "deleteConversation input");
+        const conversationId = requireConversationId(value.conversationId);
+        await this.execute((client)=>client.rpc(this.rpcNames.deleteConversation, {
+                p_project_id: this.projectId,
+                p_conversation_id: conversationId
+            }), {
+            operation: "store.deleteConversation",
+            retryNetwork: true
+        });
+    }
+    async appendMessage(input) {
+        const value = requireObject(input, "appendMessage input");
+        const { conversationId, ...message } = value;
+        const [result] = await this.appendMessages({
+            conversationId: conversationId,
+            messages: [
+                message
+            ]
+        });
+        return result;
+    }
+    async appendMessages(input) {
+        const value = requireObject(input, "appendMessages input");
+        const conversationId = requireConversationId(value.conversationId);
+        const materialized = materializeAppendMessages(value.messages, this.generateUuid);
+        const rpcMessages = materialized.map((message)=>({
+                message_id: message.messageId,
+                role: message.role,
+                event_type: message.type,
+                payload: message.payload,
+                metadata: message.metadata
+            }));
+        const data = await this.execute((client)=>client.rpc(this.rpcNames.appendMessages, {
+                p_project_id: this.projectId,
+                p_conversation_id: conversationId,
+                p_messages: rpcMessages
+            }), {
+            operation: "store.appendMessages",
+            retryNetwork: true
+        });
+        const byId = new Map(requireRows(data).map((row)=>{
+            const message = mapMessage(row);
+            return [
+                message.messageId,
+                message
+            ];
+        }));
+        if (byId.size !== materialized.length) internal();
+        return materialized.map((inputMessage)=>{
+            const message = byId.get(inputMessage.messageId);
+            if (!message || message.conversationId !== conversationId) internal();
+            return message;
+        });
+    }
+    async getMessage(input) {
+        const value = requireObject(input, "getMessage input");
+        const messageId = requireMessageId(value.messageId);
+        const data = await this.execute((client)=>client.from("events").select(MESSAGE_COLUMNS).eq("project_id", this.projectId).eq("event_id", messageId).maybeSingle(), {
+            operation: "store.getMessage",
+            retryNetwork: true
+        });
+        return null === data ? null : mapMessage(data);
+    }
+    async listMessages(input) {
+        const value = requireObject(input, "listMessages input");
+        const conversationId = requireConversationId(value.conversationId);
+        const limit = normalizeStorePageLimit(value.limit);
+        const order = value.order ?? "asc";
+        if ("asc" !== order && "desc" !== order) invalid('order must be "asc" or "desc"');
+        const cursor = void 0 === value.cursor ? void 0 : "string" == typeof value.cursor ? decodeMessageCursor(value.cursor, {
+            conversationId,
+            order
+        }) : invalid("cursor must be a string");
+        const snapshotSeq = cursor?.snapshotSeq ?? await this.readSnapshotSeq(conversationId);
+        if (null === snapshotSeq) return {
+            items: [],
+            nextCursor: null
+        };
+        const data = await this.execute((client)=>{
+            let query = client.from("events").select(MESSAGE_COLUMNS).eq("project_id", this.projectId).eq("conversation_id", conversationId).lte("seq", snapshotSeq).order("seq", {
+                ascending: "asc" === order
+            }).limit(limit + 1);
+            if (cursor) query = "asc" === order ? query.gt("seq", cursor.lastSeq) : query.lt("seq", cursor.lastSeq);
+            return query;
+        }, {
+            operation: "store.listMessages",
+            retryNetwork: true
+        });
+        const rows = requireRows(data);
+        const hasMore = rows.length > limit;
+        const items = rows.slice(0, limit).map(mapMessage);
+        const last = items.at(-1);
+        return {
+            items,
+            nextCursor: hasMore && last ? encodeMessageCursor({
+                conversationId,
+                order,
+                snapshotSeq,
+                lastSeq: last.seq
+            }) : null
+        };
+    }
+    async updateMessage(input) {
+        const value = requireObject(input, "updateMessage input");
+        const messageId = requireMessageId(value.messageId);
+        const update = {};
+        if ("role" in value) {
+            if (null !== value.role && "string" != typeof value.role) invalid("role must be a string or null");
+            update.role = value.role;
+        }
+        if ("type" in value) {
+            if (null !== value.type && "string" != typeof value.type) invalid("type must be a string or null");
+            update.event_type = value.type;
+        }
+        if ("payload" in value) update.payload = cloneJsonValue(value.payload, "payload");
+        if ("metadata" in value) update.metadata = cloneJsonObject(value.metadata, "metadata");
+        if (0 === Object.keys(update).length) invalid("updateMessage requires at least one mutable field");
+        const data = await this.execute((client)=>client.from("events").update(update).eq("project_id", this.projectId).eq("event_id", messageId).select(MESSAGE_COLUMNS).maybeSingle(), {
+            operation: "store.updateMessage",
+            retryNetwork: false
+        });
+        if (null === data) throw new StoreError("NotFound", "Message was not found");
+        return mapMessage(data);
+    }
+    async deleteMessage(input) {
+        const value = requireObject(input, "deleteMessage input");
+        const messageId = requireMessageId(value.messageId);
+        await this.execute((client)=>client.rpc(this.rpcNames.deleteMessage, {
+                p_project_id: this.projectId,
+                p_event_id: messageId
+            }), {
+            operation: "store.deleteMessage",
+            retryNetwork: true
+        });
+    }
+    async clearMessages(input) {
+        const value = requireObject(input, "clearMessages input");
+        const conversationId = requireConversationId(value.conversationId);
+        await this.execute((client)=>client.rpc(this.rpcNames.clearMessages, {
+                p_project_id: this.projectId,
+                p_conversation_id: conversationId
+            }), {
+            operation: "store.clearMessages",
+            retryNetwork: true
+        });
+    }
+    async readSnapshotSeq(conversationId) {
+        const data = await this.execute((client)=>client.from("conversations").select("next_seq").eq("project_id", this.projectId).eq("conversation_id", conversationId).maybeSingle(), {
+            operation: "store.listMessages",
+            retryNetwork: true
+        });
+        if (null === data) return null;
+        const row = requireStoreRow(data);
+        const next = BigInt(requireNextSequence(row.next_seq));
+        return next > 0n ? String(next - 1n) : "0";
+    }
+    async execute(operation, options) {
+        const result = await this.transport.execute({
+            operationName: options.operation,
+            retryOnUnauthorized: true,
+            retryOnNetworkError: options.retryNetwork,
+            operation
+        });
+        return result.data;
+    }
+    constructor(options){
+        if (!options.projectId) throw new StoreError("UnknownError", "Store project scope is missing");
+        this.projectId = options.projectId;
+        this.transport = options.transport;
+        this.generateUuid = options.generateUuid ?? randomUUID;
+        this.rpcNames = {
+            ...DEFAULT_STORE_RPC_NAMES,
+            ...options.rpcNames
+        };
+    }
+}
+function createStore(options) {
+    return new SupabaseStore(options);
+}
+function throwForStatus(status, error) {
+    throw new StoreError(storeCodeForStatus(status), error?.message ?? "Store request failed", {
+        status,
+        ...error ? {
+            error
+        } : {}
+    });
+}
+class SupabaseStoreTransport {
+    async execute(options) {
+        const attempts = options.retryOnUnauthorized || options.retryOnNetworkError ? 2 : 1;
+        for(let attempt = 0; attempt < attempts; attempt += 1){
+            const credentials = await this.credentialProvider.getValidCredentials();
+            const client = createAuthenticatedSupabaseClient({
+                credentials,
+                fetch: this.fetch,
+                createClient: this.createClient,
+                realtimeError: ()=>new StoreError("UnknownError", "Store does not support Supabase Realtime")
+            });
+            let result;
+            try {
+                result = await options.operation(client);
+            } catch (error) {
+                if (error instanceof StoreError) throw error;
+                const name = error?.name;
+                if ("AbortError" === name) throw new StoreError("AbortError", "Store request was cancelled");
+                if (options.retryOnNetworkError && attempt + 1 < attempts) continue;
+                throw new StoreError("TimeoutError" === name ? "TimeoutError" : "NetworkError", error instanceof Error ? error.message : "Store request failed");
+            }
+            if (0 !== result.status || !options.retryOnNetworkError || !(attempt + 1 < attempts)) {
+                if (401 === result.status && attempt + 1 < attempts) {
+                    this.credentialProvider.invalidate(credentials.jwt);
+                    continue;
+                }
+                if (!result.success || result.status < 200 || result.status >= 300) throwForStatus(result.status, result.error);
+                return {
+                    data: result.data,
+                    count: result.count ?? null
+                };
+            }
+        }
+        throw new StoreError("Unauthorized", "Store authorization failed");
+    }
+    constructor(options){
+        this.credentialProvider = options.credentialProvider;
+        this.fetch = options.fetch ?? globalThis.fetch;
+        this.createClient = options.createClient;
+    }
+}
+function validateStoreRootUrl(value, isAllowedHostname) {
+    try {
+        return validateDataPlaneRootUrl(value, isAllowedHostname);
+    } catch (error) {
+        throw credential_error_toStoreCredentialError(error);
+    }
+}
+async function fetchStoreCredentials(options) {
+    try {
+        return await fetchDataPlaneCredentials(options);
+    } catch (error) {
+        throw credential_error_toStoreCredentialError(error);
+    }
+}
+export { StoreCredentialProviderCache, StoreError, SupabaseStoreTransport, cloneJsonObject, createStore, credential_provider_StoreCredentialProvider, fetchStoreCredentials, validateStoreRootUrl };