@voobase/cli 0.1.1-nonprod.2039 → 0.1.1-nonprod.2050

package/runtime-sdk/dist/browser/app.js

@@ -0,0 +1,256 @@
+import { createBrowserRuntimeSdk, createBrowserSessionStore } from "../session/browser.js";
+import { classifyBrowserRuntimeError, classifyBrowserWorkflowError, getBrowserRuntimeErrorMessage, getBrowserWorkflowErrorMessage, resolveEndUserAccess } from "./errors.js";
+import { resolveCmsCoverImageSet as resolveRuntimeCmsCoverImageSet, resolveCmsCoverImageUrl as resolveRuntimeCmsCoverImageUrl, resolveCmsImageSet as resolveRuntimeCmsImageSet, resolveCmsImageUrl as resolveRuntimeCmsImageUrl } from "../cms/media.js";
+import { buildCmsCategoryNameMap as buildRuntimeCmsCategoryNameMap, resolveCmsCategoryName as resolveRuntimeCmsCategoryName, resolveCmsItemCategoryName as resolveRuntimeCmsItemCategoryName, resolveCmsItemTagLabels as resolveRuntimeCmsItemTagLabels, resolveCmsTagLabels as resolveRuntimeCmsTagLabels } from "../cms/taxonomy.js";
+export function createBrowserRuntimeApp(options) {
+    const session = options.session ?? createBrowserSessionStore(options.sessionOptions);
+    const sdk = createBrowserRuntimeSdk({
+        baseUrl: options.baseUrl,
+        appId: options.appId,
+        env: options.env,
+        fetchImpl: options.fetchImpl,
+        session,
+    });
+    const authPath = options.authPath ?? "/auth";
+    return {
+        sdk,
+        session,
+        buildSignInUrl(returnTo = getCurrentLocationPath(authPath)) {
+            const url = new URL(authPath, window.location.origin);
+            url.searchParams.set("return_to", normalizeReturnToTarget(returnTo, authPath));
+            return url.toString();
+        },
+        resolveAccess(me) {
+            return resolveEndUserAccess(me);
+        },
+        classifyError(error) {
+            return classifyBrowserRuntimeError(error);
+        },
+        classifyWorkflowError(error, params = {}) {
+            return classifyBrowserWorkflowError(error, {
+                appId: options.appId,
+                operationLabel: params.operationLabel
+            });
+        },
+        getErrorMessage(error, fallback = "运行时请求失败。") {
+            return getBrowserRuntimeErrorMessage(error, fallback);
+        },
+        getWorkflowErrorMessage(error, fallback = "Workflow 请求失败。", params = {}) {
+            return getBrowserWorkflowErrorMessage(error, fallback, {
+                appId: options.appId,
+                operationLabel: params.operationLabel
+            });
+        },
+        async getCurrentEndUser() {
+            return sdk.auth.getCurrentEndUser();
+        },
+        async getCurrentEndUserRoles() {
+            return sdk.auth.getCurrentEndUserRoles();
+        },
+        async isSignedIn() {
+            return sdk.auth.isSignedIn();
+        },
+        async getMe() {
+            return sdk.auth.getCurrentEndUser();
+        },
+        async listMyRoles() {
+            return sdk.auth.getCurrentEndUserRoles();
+        },
+        async listMyTasks(args) {
+            return sdk.workflow.listMyTasks(args);
+        },
+        async listMyNotifications(args) {
+            return sdk.notification.listMyInbox(args);
+        },
+        async getMyNotificationUnreadCount() {
+            return sdk.notification.getMyUnreadCount();
+        },
+        async listMyAnnouncements(args) {
+            return sdk.notification.listMyAnnouncements(args);
+        },
+        async markNotificationRead(itemId) {
+            return sdk.notification.markRead(itemId);
+        },
+        async dismissNotification(itemId) {
+            return sdk.notification.dismiss(itemId);
+        },
+        async getWorkflowObjectState(args) {
+            return sdk.workflow.getObjectState(args);
+        },
+        async startWorkflow(args) {
+            return sdk.workflow.startObjectWorkflow(args);
+        },
+        async performWorkflowAction(args) {
+            return sdk.workflow.performAction(args);
+        },
+        async listWorkflowTimeline(args) {
+            return sdk.workflow.listTimeline(args);
+        },
+        async listCmsItems(args) {
+            return sdk.cms.listItems(args);
+        },
+        async listCmsCollections(args) {
+            return sdk.cms.listCollections(args);
+        },
+        async uploadBlob(args) {
+            return sdk.blob.upload(args);
+        },
+        async uploadBlobFile(file, args) {
+            return sdk.blob.uploadFile(file, args);
+        },
+        async uploadBlobFiles(files, args) {
+            return sdk.blob.uploadFiles(files, args);
+        },
+        async hydrateBlobRefs(args) {
+            return sdk.blob.hydrateBlobRefs(args);
+        },
+        async hydrateRecordBlobs(args) {
+            return sdk.blob.hydrateRecordBlobs(args);
+        },
+        async getCmsCollectionMeta(args) {
+            return sdk.cms.getCollectionMeta(args);
+        },
+        async listCmsCategories(args) {
+            return sdk.cms.listCategories(args);
+        },
+        async listCmsCategoryNodes(args) {
+            const result = await sdk.cms.listCategories(args);
+            return Array.isArray(result?.nodes) ? result.nodes : [];
+        },
+        async getCmsItemBySlug(args) {
+            return sdk.cms.getItemBySlug(args);
+        },
+        async getCmsItemById(args) {
+            return sdk.cms.getItemById(args);
+        },
+        resolveCmsImageSet(value, options = {}) {
+            return resolveRuntimeCmsImageSet(value, withBrowserProtocol(options));
+        },
+        resolveCmsImageUrl(value, options = {}) {
+            return resolveRuntimeCmsImageUrl(value, withBrowserProtocol(options));
+        },
+        resolveCmsCoverImageSet(item, options = {}) {
+            return resolveRuntimeCmsCoverImageSet(item, withBrowserProtocol(options));
+        },
+        resolveCmsCoverImageUrl(item, options = {}) {
+            return resolveRuntimeCmsCoverImageUrl(item, withBrowserProtocol(options));
+        },
+        buildCmsCategoryNameMap(source) {
+            return buildRuntimeCmsCategoryNameMap(source);
+        },
+        resolveCmsCategoryName(categoryId, source, fallback = "未分类") {
+            return resolveRuntimeCmsCategoryName(categoryId, source, fallback);
+        },
+        resolveCmsItemCategoryName(item, source, fallback = "未分类") {
+            return resolveRuntimeCmsItemCategoryName(item, source, fallback);
+        },
+        resolveCmsTagLabels(value) {
+            return resolveRuntimeCmsTagLabels(value);
+        },
+        resolveCmsItemTagLabels(item) {
+            return resolveRuntimeCmsItemTagLabels(item);
+        },
+        async signOut() {
+            try {
+                await sdk.auth.signOut();
+            }
+            finally {
+                session.clearToken();
+            }
+        },
+        async ensureAuthenticated(args = {}) {
+            const shouldRedirect = args.redirectToSignIn ?? true;
+            if (!session.readToken()) {
+                if (shouldRedirect) {
+                    window.location.assign(this.buildSignInUrl(args.returnTo));
+                }
+                return null;
+            }
+            try {
+                const me = await sdk.auth.getCurrentEndUser();
+                const access = resolveEndUserAccess(me);
+                if (access.kind === "ready") {
+                    return me;
+                }
+                if (shouldRedirect && access.shouldRedirectToSignIn) {
+                    window.location.assign(this.buildSignInUrl(args.returnTo));
+                    return null;
+                }
+                return me;
+            }
+            catch (error) {
+                const resolved = classifyBrowserRuntimeError(error);
+                if (resolved.shouldClearSession) {
+                    session.clearToken();
+                }
+                if (shouldRedirect && resolved.shouldRedirectToSignIn) {
+                    window.location.assign(this.buildSignInUrl(args.returnTo));
+                    return null;
+                }
+                throw error;
+            }
+        },
+    };
+}
+function getCurrentLocationPath(authPath) {
+    if (typeof window === "undefined") {
+        return "/";
+    }
+    return normalizeReturnToTarget(`${window.location.pathname}${window.location.search}${window.location.hash}`, authPath);
+}
+function normalizeReturnToTarget(returnTo, authPath) {
+    const fallback = "/app";
+    if (typeof returnTo !== "string" || !returnTo.trim()) {
+        return fallback;
+    }
+    const candidate = returnTo.trim();
+    if (typeof window === "undefined") {
+        return candidate.startsWith("/") ? candidate : fallback;
+    }
+    let normalized = candidate;
+    if (/^https?:\/\//u.test(candidate)) {
+        const url = new URL(candidate, window.location.origin);
+        normalized = `${url.pathname}${url.search}${url.hash}`;
+    }
+    else if (!candidate.startsWith("/")) {
+        const url = new URL(candidate, window.location.origin);
+        normalized = `${url.pathname}${url.search}${url.hash}`;
+    }
+    const basePath = deriveBasePathFromAuthPath(authPath);
+    if (basePath !== "/" && (normalized === basePath || normalized.startsWith(`${basePath}/`))) {
+        const suffix = normalized.slice(basePath.length) || "/";
+        return suffix.startsWith("/") ? suffix : `/${suffix}`;
+    }
+    return normalized.startsWith("/") ? normalized : fallback;
+}
+function deriveBasePathFromAuthPath(authPath) {
+    const url = new URL(authPath, "http://platform.invalid");
+    const pathname = url.pathname.trim() || "/";
+    if (pathname === "/" || pathname === "/auth") {
+        return "/";
+    }
+    const withoutTrailingSlash = pathname.length > 1 ? pathname.replace(/\/+$/u, "") : pathname;
+    const authSuffix = "/auth";
+    if (withoutTrailingSlash === authSuffix) {
+        return "/";
+    }
+    if (withoutTrailingSlash.endsWith(authSuffix)) {
+        return withoutTrailingSlash.slice(0, -authSuffix.length) || "/";
+    }
+    return "/";
+}
+function withBrowserProtocol(options) {
+    if (options.currentProtocol) {
+        return options;
+    }
+    return {
+        ...options,
+        currentProtocol: getBrowserLocationProtocol()
+    };
+}
+function getBrowserLocationProtocol() {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    return typeof window.location?.protocol === "string" ? window.location.protocol : null;
+}

package/runtime-sdk/dist/browser/app.test.d.ts

@@ -0,0 +1 @@
+export {};

package/runtime-sdk/dist/browser/app.test.js

@@ -0,0 +1,81 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createBrowserRuntimeApp } from "./app.js";
+test("buildSignInUrl normalizes preview return target to app-internal path", () => {
+    const originalWindow = globalThis.window;
+    const location = {
+        origin: "http://127.0.0.1.nip.io",
+        pathname: "/previews/app-demo/rel-123/submit",
+        search: "?draft=1",
+        hash: "#section",
+        assign() { },
+    };
+    globalThis.window = {
+        location,
+    };
+    try {
+        const app = createBrowserRuntimeApp({
+            baseUrl: "http://127.0.0.1.nip.io/previews/app-demo/rel-123/",
+            appId: "app-demo",
+            authPath: "/previews/app-demo/rel-123/auth",
+            fetchImpl: async () => new Response(),
+        });
+        const signInUrl = new URL(app.buildSignInUrl());
+        assert.equal(signInUrl.pathname, "/previews/app-demo/rel-123/auth");
+        assert.equal(signInUrl.searchParams.get("return_to"), "/submit?draft=1#section");
+    }
+    finally {
+        globalThis.window = originalWindow;
+    }
+});
+test("buildSignInUrl accepts full platform path and stores app-internal return target", () => {
+    const originalWindow = globalThis.window;
+    globalThis.window = {
+        location: {
+            origin: "http://127.0.0.1.nip.io",
+            pathname: "/previews/app-demo/rel-123/",
+            search: "",
+            hash: "",
+            assign() { },
+        },
+    };
+    try {
+        const app = createBrowserRuntimeApp({
+            baseUrl: "http://127.0.0.1.nip.io/previews/app-demo/rel-123/",
+            appId: "app-demo",
+            authPath: "/previews/app-demo/rel-123/auth",
+            fetchImpl: async () => new Response(),
+        });
+        const signInUrl = new URL(app.buildSignInUrl("/previews/app-demo/rel-123/my-submissions/rec-1?tab=edit"));
+        assert.equal(signInUrl.searchParams.get("return_to"), "/my-submissions/rec-1?tab=edit");
+    }
+    finally {
+        globalThis.window = originalWindow;
+    }
+});
+test("buildSignInUrl keeps host-mode return target as regular path", () => {
+    const originalWindow = globalThis.window;
+    globalThis.window = {
+        location: {
+            origin: "https://app-demo.example.com",
+            pathname: "/my-submissions",
+            search: "",
+            hash: "",
+            assign() { },
+        },
+    };
+    try {
+        const app = createBrowserRuntimeApp({
+            baseUrl: "https://app-demo.example.com/",
+            appId: "app-demo",
+            authPath: "/auth",
+            fetchImpl: async () => new Response(),
+        });
+        const signInUrl = new URL(app.buildSignInUrl());
+        assert.equal(signInUrl.pathname, "/auth");
+        assert.equal(signInUrl.searchParams.get("return_to"), "/my-submissions");
+    }
+    finally {
+        globalThis.window = originalWindow;
+    }
+});

package/runtime-sdk/dist/browser/errors.d.ts

@@ -0,0 +1,39 @@
+import type { RuntimeEndUserAccessState, RuntimeEndUserAuthMe } from "../types/auth.js";
+export type BrowserRuntimeAccessKind = "ready" | "sign_in_required" | "blocked" | "not_provisioned" | "binding_unavailable" | "auth_disabled";
+export type BrowserRuntimeAccessResolution = {
+    kind: BrowserRuntimeAccessKind;
+    accessState: RuntimeEndUserAccessState;
+    message: string;
+    shouldRedirectToSignIn: boolean;
+};
+export type BrowserRuntimeErrorKind = "auth" | "business" | "network" | "server" | "unknown";
+export type BrowserRuntimeErrorResolution = {
+    kind: BrowserRuntimeErrorKind;
+    message: string;
+    status?: number;
+    code?: string;
+    requestId?: string;
+    shouldClearSession: boolean;
+    shouldRedirectToSignIn: boolean;
+    isRetryable: boolean;
+};
+export type BrowserWorkflowErrorKind = "configuration" | "permission" | "state" | "auth" | "network" | "server" | "unknown";
+export type BrowserWorkflowErrorResolution = BrowserRuntimeErrorResolution & {
+    workflowKind: BrowserWorkflowErrorKind;
+    recommendation?: string;
+    suggestedCommand?: string;
+    isConfigurationGap: boolean;
+    isPermissionGap: boolean;
+    isStateGap: boolean;
+};
+export declare function resolveEndUserAccess(me: RuntimeEndUserAuthMe | null | undefined): BrowserRuntimeAccessResolution;
+export declare function classifyBrowserRuntimeError(error: unknown): BrowserRuntimeErrorResolution;
+export declare function getBrowserRuntimeErrorMessage(error: unknown, fallback?: string): string;
+export declare function classifyBrowserWorkflowError(error: unknown, options?: {
+    appId?: string;
+    operationLabel?: string;
+}): BrowserWorkflowErrorResolution;
+export declare function getBrowserWorkflowErrorMessage(error: unknown, fallback?: string, options?: {
+    appId?: string;
+    operationLabel?: string;
+}): string;

package/runtime-sdk/dist/browser/errors.js

@@ -0,0 +1,265 @@
+import { RuntimeApiError } from "../http.js";
+export function resolveEndUserAccess(me) {
+    const accessState = me?.access_state ?? "not_authenticated";
+    switch (accessState) {
+        case "authenticated_and_ready":
+            return {
+                kind: "ready",
+                accessState,
+                message: "当前终端用户已就绪。",
+                shouldRedirectToSignIn: false,
+            };
+        case "authenticated_but_blocked":
+            return {
+                kind: "blocked",
+                accessState,
+                message: "当前终端用户已被封禁，无法继续访问当前应用。",
+                shouldRedirectToSignIn: false,
+            };
+        case "authenticated_but_not_provisioned":
+            return {
+                kind: "not_provisioned",
+                accessState,
+                message: "当前终端用户已登录，但尚未在当前应用中开通访问。",
+                shouldRedirectToSignIn: false,
+            };
+        case "binding_unavailable":
+            return {
+                kind: "binding_unavailable",
+                accessState,
+                message: "当前应用的终端用户认证绑定不可用，请联系管理员检查配置。",
+                shouldRedirectToSignIn: false,
+            };
+        case "auth_not_enabled":
+            return {
+                kind: "auth_disabled",
+                accessState,
+                message: "当前应用尚未启用终端用户认证。",
+                shouldRedirectToSignIn: false,
+            };
+        case "not_authenticated":
+        default:
+            return {
+                kind: "sign_in_required",
+                accessState: "not_authenticated",
+                message: "当前终端用户尚未登录。",
+                shouldRedirectToSignIn: true,
+            };
+    }
+}
+export function classifyBrowserRuntimeError(error) {
+    if (error instanceof RuntimeApiError) {
+        if (error.status === 401 || error.status === 403) {
+            return {
+                kind: "auth",
+                message: error.message || "当前登录态已失效，请重新登录。",
+                status: error.status,
+                code: error.code,
+                requestId: error.requestId,
+                shouldClearSession: true,
+                shouldRedirectToSignIn: true,
+                isRetryable: false,
+            };
+        }
+        if (error.status >= 500) {
+            return {
+                kind: "server",
+                message: error.message || "平台运行时服务暂时不可用，请稍后重试。",
+                status: error.status,
+                code: error.code,
+                requestId: error.requestId,
+                shouldClearSession: false,
+                shouldRedirectToSignIn: false,
+                isRetryable: true,
+            };
+        }
+        return {
+            kind: "business",
+            message: error.message || "当前请求未通过校验。",
+            status: error.status,
+            code: error.code,
+            requestId: error.requestId,
+            shouldClearSession: false,
+            shouldRedirectToSignIn: false,
+            isRetryable: false,
+        };
+    }
+    if (error instanceof TypeError) {
+        return {
+            kind: "network",
+            message: error.message || "网络请求失败，请检查当前网络或代理配置。",
+            shouldClearSession: false,
+            shouldRedirectToSignIn: false,
+            isRetryable: true,
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            kind: "unknown",
+            message: error.message || "运行时请求失败。",
+            shouldClearSession: false,
+            shouldRedirectToSignIn: false,
+            isRetryable: false,
+        };
+    }
+    return {
+        kind: "unknown",
+        message: "运行时请求失败。",
+        shouldClearSession: false,
+        shouldRedirectToSignIn: false,
+        isRetryable: false,
+    };
+}
+export function getBrowserRuntimeErrorMessage(error, fallback = "运行时请求失败。") {
+    const resolved = classifyBrowserRuntimeError(error);
+    return resolved.message || fallback;
+}
+export function classifyBrowserWorkflowError(error, options = {}) {
+    const resolved = classifyBrowserRuntimeError(error);
+    const operationLabel = options.operationLabel?.trim() || "Workflow 请求";
+    const suggestedDiagnoseCommand = options.appId
+        ? `platform workflow diagnose --app ${options.appId}`
+        : "platform workflow diagnose";
+    const fallback = {
+        ...resolved,
+        workflowKind: resolved.kind === "auth"
+            ? "auth"
+            : resolved.kind === "network"
+                ? "network"
+                : resolved.kind === "server"
+                    ? "server"
+                    : "unknown",
+        recommendation: resolved.kind === "auth"
+            ? "请重新登录后重试。"
+            : resolved.kind === "network" || resolved.kind === "server"
+                ? "稍后重试；如果持续失败，请检查平台运行时与控制面服务状态。"
+                : "先刷新状态；若仍失败，再检查 workflow 定义、绑定与角色绑定。",
+        suggestedCommand: resolved.kind === "auth" || resolved.kind === "network" || resolved.kind === "server"
+            ? undefined
+            : suggestedDiagnoseCommand,
+        isConfigurationGap: false,
+        isPermissionGap: false,
+        isStateGap: false
+    };
+    switch (resolved.code) {
+        case "workflow_definition_not_found":
+            return {
+                ...resolved,
+                workflowKind: "configuration",
+                message: "当前应用尚未找到对应的 Workflow 定义或绑定。",
+                recommendation: `先检查 definition 与 app binding；可执行 \`${suggestedDiagnoseCommand}\`。`,
+                suggestedCommand: suggestedDiagnoseCommand,
+                isConfigurationGap: true,
+                isPermissionGap: false,
+                isStateGap: false
+            };
+        case "workflow_definition_not_active":
+            return {
+                ...resolved,
+                workflowKind: "configuration",
+                message: "当前 Workflow 定义存在，但还不是 active 状态。",
+                recommendation: "请先激活定义，再继续启动或执行动作。",
+                suggestedCommand: suggestedDiagnoseCommand,
+                isConfigurationGap: true,
+                isPermissionGap: false,
+                isStateGap: false
+            };
+        case "workflow_runtime_principal_invalid":
+        case "workflow_runtime_session_invalid":
+            return {
+                ...resolved,
+                workflowKind: "auth",
+                message: "当前 Workflow 运行时需要有效的终端用户会话，请重新登录后重试。",
+                recommendation: "重新登录当前轻应用，再继续访问 workflow 页面。",
+                suggestedCommand: undefined,
+                isConfigurationGap: false,
+                isPermissionGap: false,
+                isStateGap: false
+            };
+        case "workflow_instance_already_active":
+            return {
+                ...resolved,
+                workflowKind: "state",
+                message: "该对象已经有进行中的流程实例，不需要重复启动。",
+                recommendation: "直接刷新当前对象状态，或继续执行后续动作。",
+                suggestedCommand: undefined,
+                isConfigurationGap: false,
+                isPermissionGap: false,
+                isStateGap: true
+            };
+        case "workflow_instance_not_found":
+            return {
+                ...resolved,
+                workflowKind: "state",
+                message: "当前对象还没有对应的流程实例。",
+                recommendation: "请先启动流程，再执行动作或查看时间线。",
+                suggestedCommand: undefined,
+                isConfigurationGap: false,
+                isPermissionGap: false,
+                isStateGap: true
+            };
+        case "workflow_instance_not_active":
+            return {
+                ...resolved,
+                workflowKind: "state",
+                message: "当前流程实例已结束，不能继续执行动作。",
+                recommendation: "刷新状态后查看当前对象是否需要重新打开或重新启动流程。",
+                suggestedCommand: undefined,
+                isConfigurationGap: false,
+                isPermissionGap: false,
+                isStateGap: true
+            };
+        case "workflow_action_not_found":
+            return {
+                ...resolved,
+                workflowKind: "configuration",
+                message: "当前动作不存在，可能是流程定义或页面状态已经过期。",
+                recommendation: "先刷新状态；如果仍然缺失，请检查 binding override 或最近的 definition 变更。",
+                suggestedCommand: suggestedDiagnoseCommand,
+                isConfigurationGap: true,
+                isPermissionGap: false,
+                isStateGap: false
+            };
+        case "workflow_transition_not_allowed":
+            return {
+                ...resolved,
+                workflowKind: "state",
+                message: "当前状态不允许执行这个动作。",
+                recommendation: "先刷新 workflow 状态，确认当前对象仍处于可执行该动作的状态。",
+                suggestedCommand: undefined,
+                isConfigurationGap: false,
+                isPermissionGap: false,
+                isStateGap: true
+            };
+        case "workflow_action_forbidden":
+            return {
+                ...resolved,
+                workflowKind: "permission",
+                message: "当前终端用户没有执行这个动作的权限。",
+                recommendation: `检查 workflow role binding 是否把当前用户角色映射到该动作；可执行 \`${suggestedDiagnoseCommand}\`。`,
+                suggestedCommand: suggestedDiagnoseCommand,
+                isConfigurationGap: false,
+                isPermissionGap: true,
+                isStateGap: false
+            };
+        case "workflow_schema_invalid":
+        case "workflow_state_not_found":
+        case "workflow_instance_update_failed":
+            return {
+                ...resolved,
+                workflowKind: "server",
+                message: `${operationLabel}失败，Workflow 定义或实例数据存在异常。`,
+                recommendation: "检查 workflow schema、binding override 与控制面日志。",
+                suggestedCommand: suggestedDiagnoseCommand,
+                isConfigurationGap: false,
+                isPermissionGap: false,
+                isStateGap: false
+            };
+        default:
+            return fallback;
+    }
+}
+export function getBrowserWorkflowErrorMessage(error, fallback = "Workflow 请求失败。", options = {}) {
+    const resolved = classifyBrowserWorkflowError(error, options);
+    return resolved.message || fallback;
+}

package/runtime-sdk/dist/browser/errors.test.d.ts

@@ -0,0 +1 @@
+export {};