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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voobase/cli",
-  "version": "0.1.1-nonprod.2039",
+  "version": "0.1.1-nonprod.2051",
   "private": false,
   "platformDistributionProfile": {
     "name": "nonprod",
@@ -20,6 +20,9 @@
   "bin": {
     "platform": "dist-bundle/index.mjs"
   },
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "scripts": {
     "dev": "tsx watch src/index.ts --help",
     "build": "corepack pnpm --filter @platform/sdk build && corepack pnpm --filter @platform/capability-auth build && corepack pnpm --filter @platform/capability-cms build && corepack pnpm --filter @platform/capability-data-form build && tsc -p tsconfig.json",
@@ -53,10 +56,10 @@
   "bundleDependencies": [],
   "platformDistributionBuild": {
     "channel": "nonprod",
-    "version": "0.1.1-nonprod.2039",
-    "sequence": 2039,
-    "gitSha": "e5d1c1f",
-    "fullGitSha": "e5d1c1f21da6f231f3c7d42fe227ae44b4b16ca1",
-    "buildId": "0.1.1-nonprod.2039+e5d1c1f"
+    "version": "0.1.1-nonprod.2051",
+    "sequence": 2051,
+    "gitSha": "af1febe",
+    "fullGitSha": "af1febe76cef4519c4ed2150bdde045a61ff0390",
+    "buildId": "0.1.1-nonprod.2051+af1febe"
   }
 }

package/runtime-sdk/dist/auth/client.d.ts

@@ -0,0 +1,14 @@
+import { BaseRuntimeSdk, type RuntimeSdkOptions } from "../http.js";
+import type { RuntimeEndUserAuthMe, RuntimeEndUserRoleRecord } from "../types/auth.js";
+export declare class RuntimeAuthClient extends BaseRuntimeSdk {
+    constructor(options: RuntimeSdkOptions);
+    getCurrentEndUser(): Promise<RuntimeEndUserAuthMe>;
+    getCurrentEndUserRoles(): Promise<RuntimeEndUserRoleRecord[]>;
+    isSignedIn(): Promise<boolean>;
+    getMe(): Promise<RuntimeEndUserAuthMe>;
+    listMyRoles(): Promise<RuntimeEndUserRoleRecord[]>;
+    signOut(): Promise<{
+        app_id: string;
+        signed_out: true;
+    }>;
+}

package/runtime-sdk/dist/auth/client.js

@@ -0,0 +1,28 @@
+import { BaseRuntimeSdk } from "../http.js";
+export class RuntimeAuthClient extends BaseRuntimeSdk {
+    constructor(options) {
+        super(options);
+    }
+    async getCurrentEndUser() {
+        return this.requestApp("/end-user-auth/me");
+    }
+    async getCurrentEndUserRoles() {
+        const result = await this.requestApp("/end-user-auth/roles");
+        return result.items;
+    }
+    async isSignedIn() {
+        const me = await this.getCurrentEndUser();
+        return me.access_state === "authenticated_and_ready";
+    }
+    async getMe() {
+        return this.getCurrentEndUser();
+    }
+    async listMyRoles() {
+        return this.getCurrentEndUserRoles();
+    }
+    async signOut() {
+        return this.requestApp("/end-user-auth/sign-out", {
+            method: "POST"
+        });
+    }
+}

package/runtime-sdk/dist/blob/client.d.ts

@@ -0,0 +1,39 @@
+import { BaseRuntimeSdk, type RuntimeSdkOptions } from "../http.js";
+import type { RuntimeBlobHydrateResponse, RuntimeBlobUploadSession, RuntimeCompleteBlobUploadInput, RuntimeCompleteBlobUploadResult, RuntimeCreateBlobUploadSessionInput, RuntimeHydrateBlobRefsInput, RuntimeHydrateRecordBlobsInput } from "../types/object-storage.js";
+export type RuntimeBlobBinaryBody = Blob | ArrayBuffer | ArrayBufferView;
+export declare class RuntimeBlobClient extends BaseRuntimeSdk {
+    private cachedUploadTicket;
+    constructor(options: RuntimeSdkOptions);
+    createUploadSession(input: RuntimeCreateBlobUploadSessionInput): Promise<RuntimeBlobUploadSession>;
+    uploadBinary(args: {
+        uploadUrl: string;
+        body: RuntimeBlobBinaryBody;
+        contentType: string;
+        headers?: Record<string, string>;
+    }): Promise<void>;
+    completeUpload(uploadSessionId: string, input?: RuntimeCompleteBlobUploadInput): Promise<RuntimeCompleteBlobUploadResult>;
+    upload(args: RuntimeCreateBlobUploadSessionInput & {
+        body: RuntimeBlobBinaryBody;
+        sha256?: string;
+    }): Promise<RuntimeCompleteBlobUploadResult>;
+    uploadFile(file: Blob & {
+        name?: string;
+    }, args?: Omit<RuntimeCreateBlobUploadSessionInput, "original_filename" | "content_type" | "size_bytes"> & {
+        original_filename?: string;
+        content_type?: string;
+        sha256?: string;
+    }): Promise<RuntimeCompleteBlobUploadResult>;
+    uploadFiles(files: Array<Blob & {
+        name?: string;
+    }>, args?: Omit<RuntimeCreateBlobUploadSessionInput, "original_filename" | "content_type" | "size_bytes"> & {
+        original_filenames?: string[];
+        content_types?: string[];
+        sha256_list?: Array<string | undefined>;
+    }): Promise<RuntimeCompleteBlobUploadResult[]>;
+    hydrateBlobRefs(args: RuntimeHydrateBlobRefsInput): Promise<RuntimeBlobHydrateResponse>;
+    hydrateRecordBlobs(args: RuntimeHydrateRecordBlobsInput): Promise<RuntimeBlobHydrateResponse>;
+    private createUploadTicket;
+    private withUploadTicket;
+    private clearUploadTicket;
+    private ensureUploadTicket;
+}

package/runtime-sdk/dist/blob/client.js

@@ -0,0 +1,148 @@
+import { BaseRuntimeSdk, RuntimeApiError } from "../http.js";
+const UPLOAD_TICKET_REFRESH_SKEW_MS = 30_000;
+const UPLOAD_TICKET_RETRYABLE_CODES = new Set(["missing_credentials", "ticket_invalid"]);
+export class RuntimeBlobClient extends BaseRuntimeSdk {
+    cachedUploadTicket = null;
+    constructor(options) {
+        super(options);
+    }
+    async createUploadSession(input) {
+        return this.withUploadTicket((ticket) => this.requestApp("/blobs/upload-sessions", {
+            method: "POST",
+            headers: {
+                Authorization: `Ticket ${ticket}`
+            },
+            body: JSON.stringify(input)
+        }));
+    }
+    async uploadBinary(args) {
+        await this.withUploadTicket(async (ticket) => {
+            const url = /^https?:\/\//i.test(args.uploadUrl)
+                ? new URL(args.uploadUrl)
+                : this.buildRequestUrl(args.uploadUrl);
+            const headers = new Headers(args.headers);
+            headers.set("Authorization", `Ticket ${ticket}`);
+            headers.set("Content-Type", args.contentType);
+            await this.requestVoidUrl(url, {
+                method: "PUT",
+                headers,
+                body: toRequestBody(args.body)
+            });
+        });
+    }
+    async completeUpload(uploadSessionId, input = {}) {
+        return this.withUploadTicket((ticket) => this.requestApp(`/blobs/upload-sessions/${encodeURIComponent(uploadSessionId)}/complete`, {
+            method: "POST",
+            headers: {
+                Authorization: `Ticket ${ticket}`
+            },
+            body: JSON.stringify(input)
+        }));
+    }
+    async upload(args) {
+        const { body, sha256, ...createInput } = args;
+        const session = await this.createUploadSession(createInput);
+        const contentType = args.content_type?.trim();
+        if (!contentType) {
+            throw new Error("content_type is required for runtime blob upload.");
+        }
+        await this.uploadBinary({
+            uploadUrl: session.upload_url,
+            body,
+            contentType,
+            headers: session.headers
+        });
+        return this.completeUpload(session.upload_session_id, {
+            ...(sha256 ? { sha256 } : {}),
+            ...(args.size_bytes !== undefined ? { size_bytes: args.size_bytes } : {})
+        });
+    }
+    async uploadFile(file, args = {}) {
+        const originalFilename = args.original_filename?.trim() || file.name?.trim() || "blob.bin";
+        const contentType = args.content_type?.trim() || file.type?.trim() || "application/octet-stream";
+        return this.upload({
+            ...args,
+            original_filename: originalFilename,
+            content_type: contentType,
+            size_bytes: Number.isFinite(file.size) ? file.size : undefined,
+            body: file
+        });
+    }
+    async uploadFiles(files, args = {}) {
+        const results = [];
+        for (const [index, file] of files.entries()) {
+            results.push(await this.uploadFile(file, {
+                ...args,
+                ...(args.original_filenames?.[index] ? { original_filename: args.original_filenames[index] } : {}),
+                ...(args.content_types?.[index] ? { content_type: args.content_types[index] } : {}),
+                ...(args.sha256_list?.[index] ? { sha256: args.sha256_list[index] } : {})
+            }));
+        }
+        return results;
+    }
+    async hydrateBlobRefs(args) {
+        return this.requestApp("/blobs/hydrate", {
+            method: "POST",
+            body: JSON.stringify({
+                items: args.items
+            })
+        });
+    }
+    async hydrateRecordBlobs(args) {
+        return this.requestApp("/blobs/hydrate", {
+            method: "POST",
+            body: JSON.stringify({
+                resource_key: args.resourceKey,
+                record_id: args.recordId
+            })
+        });
+    }
+    async createUploadTicket() {
+        return this.requestApp("/blobs/upload-ticket", {
+            method: "POST"
+        });
+    }
+    async withUploadTicket(runner) {
+        const ticket = await this.ensureUploadTicket();
+        try {
+            return await runner(ticket);
+        }
+        catch (error) {
+            if (!isUploadTicketRetryableError(error)) {
+                throw error;
+            }
+            this.clearUploadTicket();
+            return runner(await this.ensureUploadTicket());
+        }
+    }
+    clearUploadTicket() {
+        this.cachedUploadTicket = null;
+    }
+    async ensureUploadTicket() {
+        if (this.cachedUploadTicket && this.cachedUploadTicket.expiresAtMs - UPLOAD_TICKET_REFRESH_SKEW_MS > Date.now()) {
+            return this.cachedUploadTicket.value;
+        }
+        const next = await this.createUploadTicket();
+        const expiresAtMs = Date.parse(next.expires_at);
+        this.cachedUploadTicket = {
+            value: next.upload_ticket,
+            expiresAtMs: Number.isFinite(expiresAtMs) ? expiresAtMs : Date.now()
+        };
+        return next.upload_ticket;
+    }
+}
+function toRequestBody(body) {
+    if (body instanceof ArrayBuffer) {
+        return body;
+    }
+    if (ArrayBuffer.isView(body)) {
+        return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+    }
+    return body;
+}
+function isUploadTicketRetryableError(error) {
+    return (error instanceof RuntimeApiError &&
+        error.status === 401 &&
+        typeof error.code === "string" &&
+        UPLOAD_TICKET_RETRYABLE_CODES.has(error.code));
+}

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

@@ -0,0 +1,142 @@
+import { type BrowserSessionStore, type BrowserSessionStoreOptions } from "../session/browser.js";
+import { type RuntimeCmsMediaUrlOptions } from "../cms/media.js";
+import type { RuntimeWorkflowActionResult, RuntimeWorkflowObjectState, RuntimeWorkflowStartResult, RuntimeWorkflowTaskList, RuntimeWorkflowTimelineItem } from "../types/workflow.js";
+import type { RuntimeNotificationAnnouncements, RuntimeNotificationCommandResult, RuntimeNotificationInboxItemStatus, RuntimeNotificationInboxList, RuntimeNotificationUnreadCount } from "../types/notification.js";
+import type { RuntimeCmsCategoryNode, RuntimeCmsCategoryTreeResponse, RuntimeCmsCollectionListResponse, RuntimeCmsCollectionMetaResponse, RuntimeCmsDeliveryListResponse, RuntimeCmsImageSet, RuntimeCmsItemDeliveryPayload } from "../types/cms.js";
+import type { RuntimeEndUserAuthMe, RuntimeEndUserRoleRecord } from "../types/auth.js";
+import type { RuntimeBlobHydrateResponse, RuntimeCompleteBlobUploadResult, RuntimeCreateBlobUploadSessionInput, RuntimeHydrateBlobRefsInput, RuntimeHydrateRecordBlobsInput } from "../types/object-storage.js";
+export type BrowserRuntimeAppOptions = {
+    baseUrl: string;
+    appId: string;
+    env?: "preview" | "prod";
+    session?: BrowserSessionStore;
+    sessionOptions?: BrowserSessionStoreOptions;
+    authPath?: string;
+    fetchImpl?: typeof fetch;
+};
+export declare function createBrowserRuntimeApp(options: BrowserRuntimeAppOptions): {
+    sdk: import("../client.js").PlatformRuntimeSdk;
+    session: BrowserSessionStore;
+    buildSignInUrl(returnTo?: string): string;
+    resolveAccess(me: RuntimeEndUserAuthMe | null | undefined): import("./errors.js").BrowserRuntimeAccessResolution;
+    classifyError(error: unknown): import("./errors.js").BrowserRuntimeErrorResolution;
+    classifyWorkflowError(error: unknown, params?: {
+        operationLabel?: string;
+    }): import("./errors.js").BrowserWorkflowErrorResolution;
+    getErrorMessage(error: unknown, fallback?: string): string;
+    getWorkflowErrorMessage(error: unknown, fallback?: string, params?: {
+        operationLabel?: string;
+    }): string;
+    getCurrentEndUser(): Promise<RuntimeEndUserAuthMe>;
+    getCurrentEndUserRoles(): Promise<RuntimeEndUserRoleRecord[]>;
+    isSignedIn(): Promise<boolean>;
+    getMe(): Promise<RuntimeEndUserAuthMe>;
+    listMyRoles(): Promise<RuntimeEndUserRoleRecord[]>;
+    listMyTasks(args?: {
+        status?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<RuntimeWorkflowTaskList>;
+    listMyNotifications(args?: {
+        status?: RuntimeNotificationInboxItemStatus;
+        inboxType?: "task_projection" | "notification" | "alert" | "announcement";
+        limit?: number;
+    }): Promise<RuntimeNotificationInboxList>;
+    getMyNotificationUnreadCount(): Promise<RuntimeNotificationUnreadCount>;
+    listMyAnnouncements(args?: {
+        limit?: number;
+    }): Promise<RuntimeNotificationAnnouncements>;
+    markNotificationRead(itemId: string): Promise<RuntimeNotificationCommandResult>;
+    dismissNotification(itemId: string): Promise<RuntimeNotificationCommandResult>;
+    getWorkflowObjectState(args: {
+        objectType: string;
+        objectId: string;
+    }): Promise<RuntimeWorkflowObjectState>;
+    startWorkflow(args: {
+        definitionKey: string;
+        objectType: string;
+        objectId: string;
+        payload?: Record<string, unknown>;
+    }): Promise<RuntimeWorkflowStartResult>;
+    performWorkflowAction(args: {
+        instanceId: string;
+        actionKey: string;
+        comment?: string;
+        payload?: Record<string, unknown>;
+    }): Promise<RuntimeWorkflowActionResult>;
+    listWorkflowTimeline(args: {
+        objectType: string;
+        objectId: string;
+    }): Promise<RuntimeWorkflowTimelineItem[]>;
+    listCmsItems(args: {
+        tenantId: string;
+        collection: string;
+        page?: number;
+        pageSize?: number;
+        categoryId?: string;
+        tags?: string[];
+        featured?: boolean;
+        sortField?: string;
+        sortDirection?: "asc" | "desc";
+        q?: string;
+    }): Promise<RuntimeCmsDeliveryListResponse>;
+    listCmsCollections(args: {
+        tenantId: string;
+    }): Promise<RuntimeCmsCollectionListResponse>;
+    uploadBlob(args: RuntimeCreateBlobUploadSessionInput & {
+        body: Blob | ArrayBuffer | ArrayBufferView;
+        sha256?: string;
+    }): Promise<RuntimeCompleteBlobUploadResult>;
+    uploadBlobFile(file: Blob & {
+        name?: string;
+    }, args?: Omit<RuntimeCreateBlobUploadSessionInput, "original_filename" | "content_type" | "size_bytes"> & {
+        original_filename?: string;
+        content_type?: string;
+        sha256?: string;
+    }): Promise<RuntimeCompleteBlobUploadResult>;
+    uploadBlobFiles(files: Array<Blob & {
+        name?: string;
+    }>, args?: Omit<RuntimeCreateBlobUploadSessionInput, "original_filename" | "content_type" | "size_bytes"> & {
+        original_filenames?: string[];
+        content_types?: string[];
+        sha256_list?: Array<string | undefined>;
+    }): Promise<RuntimeCompleteBlobUploadResult[]>;
+    hydrateBlobRefs(args: RuntimeHydrateBlobRefsInput): Promise<RuntimeBlobHydrateResponse>;
+    hydrateRecordBlobs(args: RuntimeHydrateRecordBlobsInput): Promise<RuntimeBlobHydrateResponse>;
+    getCmsCollectionMeta(args: {
+        tenantId: string;
+        collection: string;
+    }): Promise<RuntimeCmsCollectionMetaResponse>;
+    listCmsCategories(args: {
+        tenantId: string;
+        collection: string;
+    }): Promise<RuntimeCmsCategoryTreeResponse>;
+    listCmsCategoryNodes(args: {
+        tenantId: string;
+        collection: string;
+    }): Promise<RuntimeCmsCategoryNode[]>;
+    getCmsItemBySlug(args: {
+        tenantId: string;
+        collection: string;
+        slug: string;
+    }): Promise<RuntimeCmsItemDeliveryPayload>;
+    getCmsItemById(args: {
+        tenantId: string;
+        collection: string;
+        itemId: string;
+    }): Promise<RuntimeCmsItemDeliveryPayload>;
+    resolveCmsImageSet(value: unknown, options?: RuntimeCmsMediaUrlOptions): RuntimeCmsImageSet | null;
+    resolveCmsImageUrl(value: unknown, options?: RuntimeCmsMediaUrlOptions): string | null;
+    resolveCmsCoverImageSet(item: RuntimeCmsItemDeliveryPayload, options?: RuntimeCmsMediaUrlOptions): RuntimeCmsImageSet | null;
+    resolveCmsCoverImageUrl(item: RuntimeCmsItemDeliveryPayload, options?: RuntimeCmsMediaUrlOptions): string | null;
+    buildCmsCategoryNameMap(source: RuntimeCmsCollectionMetaResponse | RuntimeCmsCategoryNode[] | Map<string, string> | null | undefined): Map<string, string>;
+    resolveCmsCategoryName(categoryId: unknown, source: RuntimeCmsCollectionMetaResponse | RuntimeCmsCategoryNode[] | Map<string, string> | null | undefined, fallback?: string): string;
+    resolveCmsItemCategoryName(item: RuntimeCmsItemDeliveryPayload, source: RuntimeCmsCollectionMetaResponse | RuntimeCmsCategoryNode[] | Map<string, string> | null | undefined, fallback?: string): string;
+    resolveCmsTagLabels(value: unknown): string[];
+    resolveCmsItemTagLabels(item: RuntimeCmsItemDeliveryPayload): string[];
+    signOut(): Promise<void>;
+    ensureAuthenticated(args?: {
+        returnTo?: string;
+        redirectToSignIn?: boolean;
+    }): Promise<RuntimeEndUserAuthMe | null>;
+};

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