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

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

@@ -0,0 +1,41 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { RuntimeApiError } from "../http.js";
+import { classifyBrowserWorkflowError } from "./errors.js";
+test("classifyBrowserWorkflowError maps definition gaps to configuration guidance", () => {
+    const error = new RuntimeApiError("workflow definition was not found", 404, "workflow_definition_not_found", {
+        definition_key: "wf-demo"
+    }, "req-demo-1");
+    const resolved = classifyBrowserWorkflowError(error, {
+        appId: "app-demo",
+        operationLabel: "Workflow 启动"
+    });
+    assert.equal(resolved.workflowKind, "configuration");
+    assert.equal(resolved.isConfigurationGap, true);
+    assert.match(resolved.message, /Workflow 定义或绑定/);
+    assert.match(resolved.recommendation ?? "", /platform workflow diagnose --app app-demo/);
+});
+test("classifyBrowserWorkflowError maps forbidden actions to role-binding guidance", () => {
+    const error = new RuntimeApiError("principal is not allowed to perform this action", 403, "workflow_action_forbidden", {
+        action_key: "approve"
+    }, "req-demo-2");
+    const resolved = classifyBrowserWorkflowError(error, {
+        appId: "app-demo"
+    });
+    assert.equal(resolved.workflowKind, "permission");
+    assert.equal(resolved.isPermissionGap, true);
+    assert.match(resolved.message, /没有执行这个动作的权限/);
+    assert.match(resolved.recommendation ?? "", /role binding/);
+});
+test("classifyBrowserWorkflowError maps already-active instances to state guidance", () => {
+    const error = new RuntimeApiError("an active workflow instance already exists for this object", 409, "workflow_instance_already_active", {
+        object_id: "demo-request-001"
+    }, "req-demo-3");
+    const resolved = classifyBrowserWorkflowError(error, {
+        appId: "app-demo"
+    });
+    assert.equal(resolved.workflowKind, "state");
+    assert.equal(resolved.isStateGap, true);
+    assert.match(resolved.message, /已经有进行中的流程实例/);
+    assert.match(resolved.recommendation ?? "", /刷新当前对象状态/);
+});

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

@@ -0,0 +1,5 @@
+export { createBrowserRuntimeApp, type BrowserRuntimeAppOptions } from "./browser/app.js";
+export { normalizeCmsMediaUrl, resolveCmsCoverImageSet, resolveCmsCoverImageUrl, resolveCmsImageSet, resolveCmsImageUrl, type RuntimeCmsMediaUrlOptions } from "./cms/media.js";
+export { buildCmsCategoryNameMap, resolveCmsCategoryName, resolveCmsItemCategoryName, resolveCmsItemTagLabels, resolveCmsTagLabels } from "./cms/taxonomy.js";
+export { classifyBrowserRuntimeError, classifyBrowserWorkflowError, getBrowserRuntimeErrorMessage, getBrowserWorkflowErrorMessage, resolveEndUserAccess, type BrowserRuntimeAccessKind, type BrowserRuntimeAccessResolution, type BrowserRuntimeErrorKind, type BrowserRuntimeErrorResolution, type BrowserWorkflowErrorKind, type BrowserWorkflowErrorResolution, } from "./browser/errors.js";
+export { buildEndUserSessionStorageKey, createBrowserRuntimeSdk, createBrowserSessionStore, type BrowserSessionStore, type BrowserSessionStoreOptions } from "./session/browser.js";

package/runtime-sdk/dist/browser.js

@@ -0,0 +1,5 @@
+export { createBrowserRuntimeApp } from "./browser/app.js";
+export { normalizeCmsMediaUrl, resolveCmsCoverImageSet, resolveCmsCoverImageUrl, resolveCmsImageSet, resolveCmsImageUrl } from "./cms/media.js";
+export { buildCmsCategoryNameMap, resolveCmsCategoryName, resolveCmsItemCategoryName, resolveCmsItemTagLabels, resolveCmsTagLabels } from "./cms/taxonomy.js";
+export { classifyBrowserRuntimeError, classifyBrowserWorkflowError, getBrowserRuntimeErrorMessage, getBrowserWorkflowErrorMessage, resolveEndUserAccess, } from "./browser/errors.js";
+export { buildEndUserSessionStorageKey, createBrowserRuntimeSdk, createBrowserSessionStore } from "./session/browser.js";

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

@@ -0,0 +1,16 @@
+import type { RuntimeSdkOptions } from "./http.js";
+import { RuntimeAuthClient } from "./auth/client.js";
+import { RuntimeBlobClient } from "./blob/client.js";
+import { RuntimeCmsClient } from "./cms/client.js";
+import { RuntimeDataFormClient } from "./data-form/client.js";
+import { RuntimeNotificationClient } from "./notification/client.js";
+import { RuntimeWorkflowClient } from "./workflow/client.js";
+export declare class PlatformRuntimeSdk {
+    readonly auth: RuntimeAuthClient;
+    readonly blob: RuntimeBlobClient;
+    readonly cms: RuntimeCmsClient;
+    readonly dataForm: RuntimeDataFormClient;
+    readonly notification: RuntimeNotificationClient;
+    readonly workflow: RuntimeWorkflowClient;
+    constructor(options: RuntimeSdkOptions);
+}

package/runtime-sdk/dist/client.js

@@ -0,0 +1,22 @@
+import { RuntimeAuthClient } from "./auth/client.js";
+import { RuntimeBlobClient } from "./blob/client.js";
+import { RuntimeCmsClient } from "./cms/client.js";
+import { RuntimeDataFormClient } from "./data-form/client.js";
+import { RuntimeNotificationClient } from "./notification/client.js";
+import { RuntimeWorkflowClient } from "./workflow/client.js";
+export class PlatformRuntimeSdk {
+    auth;
+    blob;
+    cms;
+    dataForm;
+    notification;
+    workflow;
+    constructor(options) {
+        this.auth = new RuntimeAuthClient(options);
+        this.blob = new RuntimeBlobClient(options);
+        this.cms = new RuntimeCmsClient(options);
+        this.dataForm = new RuntimeDataFormClient(options);
+        this.notification = new RuntimeNotificationClient(options);
+        this.workflow = new RuntimeWorkflowClient(options);
+    }
+}

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

@@ -0,0 +1,39 @@
+import { BaseRuntimeSdk, type RuntimeSdkOptions } from "../http.js";
+import type { RuntimeCmsCategoryTreeResponse, RuntimeCmsCollectionListResponse, RuntimeCmsCollectionMetaResponse, RuntimeCmsDeliveryListResponse, RuntimeCmsItemDeliveryPayload } from "../types/cms.js";
+export declare class RuntimeCmsClient extends BaseRuntimeSdk {
+    constructor(options: RuntimeSdkOptions);
+    private buildCmsPath;
+    listCollections(args: {
+        tenantId: string;
+    }): Promise<RuntimeCmsCollectionListResponse>;
+    getCollectionMeta(args: {
+        tenantId: string;
+        collection: string;
+    }): Promise<RuntimeCmsCollectionMetaResponse>;
+    listItems(args: {
+        tenantId: string;
+        collection: string;
+        page?: number;
+        pageSize?: number;
+        categoryId?: string;
+        tags?: string[];
+        featured?: boolean;
+        sortField?: string;
+        sortDirection?: "asc" | "desc";
+        q?: string;
+    }): Promise<RuntimeCmsDeliveryListResponse>;
+    listCategories(args: {
+        tenantId: string;
+        collection: string;
+    }): Promise<RuntimeCmsCategoryTreeResponse>;
+    getItemBySlug(args: {
+        tenantId: string;
+        collection: string;
+        slug: string;
+    }): Promise<RuntimeCmsItemDeliveryPayload>;
+    getItemById(args: {
+        tenantId: string;
+        collection: string;
+        itemId: string;
+    }): Promise<RuntimeCmsItemDeliveryPayload>;
+}

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

@@ -0,0 +1,56 @@
+import { BaseRuntimeSdk } from "../http.js";
+export class RuntimeCmsClient extends BaseRuntimeSdk {
+    constructor(options) {
+        super(options);
+    }
+    buildCmsPath(path, tenantId, configure) {
+        const normalizedPath = typeof path === "string" ? path.replace(/^\/+/, "") : "";
+        const url = new URL(normalizedPath, "http://platform.local/");
+        url.searchParams.set("tenant_id", tenantId);
+        configure?.(url.searchParams);
+        return `${url.pathname}${url.search}`;
+    }
+    async listCollections(args) {
+        return this.request(this.buildCmsPath("/api/public/cms/collections", args.tenantId));
+    }
+    async getCollectionMeta(args) {
+        return this.request(this.buildCmsPath(`/api/public/cms/collections/${encodeURIComponent(args.collection)}/meta`, args.tenantId));
+    }
+    async listItems(args) {
+        return this.request(this.buildCmsPath(`/api/public/cms/collections/${encodeURIComponent(args.collection)}/items`, args.tenantId, (params) => {
+            if (args.page !== undefined) {
+                params.set("page", String(args.page));
+            }
+            if (args.pageSize !== undefined) {
+                params.set("page_size", String(args.pageSize));
+            }
+            if (args.categoryId) {
+                params.set("category_id", args.categoryId);
+            }
+            if (args.sortField) {
+                params.set("sort_field", args.sortField);
+            }
+            if (args.sortDirection) {
+                params.set("sort_direction", args.sortDirection);
+            }
+            if (args.q?.trim()) {
+                params.set("q", args.q.trim());
+            }
+            if (typeof args.featured === "boolean") {
+                params.set("featured", String(args.featured));
+            }
+            for (const tag of args.tags ?? []) {
+                params.append("tag", tag);
+            }
+        }));
+    }
+    async listCategories(args) {
+        return this.request(this.buildCmsPath(`/api/public/cms/collections/${encodeURIComponent(args.collection)}/categories`, args.tenantId));
+    }
+    async getItemBySlug(args) {
+        return this.request(this.buildCmsPath(`/api/public/cms/collections/${encodeURIComponent(args.collection)}/items/by-slug/${encodeURIComponent(args.slug)}`, args.tenantId));
+    }
+    async getItemById(args) {
+        return this.request(this.buildCmsPath(`/api/public/cms/collections/${encodeURIComponent(args.collection)}/items/${encodeURIComponent(args.itemId)}`, args.tenantId));
+    }
+}

package/runtime-sdk/dist/cms/client.test.d.ts

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

package/runtime-sdk/dist/cms/client.test.js

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { PlatformRuntimeSdk } from "../client.js";
+test("runtime cms client keeps mounted preview path single when building requests", async () => {
+    const calls = [];
+    const sdk = new PlatformRuntimeSdk({
+        baseUrl: "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/",
+        appId: "app-demo",
+        fetchImpl: async (input) => {
+            const url = String(input);
+            calls.push(url);
+            if (url === "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/cms/collections?tenant_id=t-demo") {
+                return new Response(JSON.stringify({ collections: [] }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    const result = await sdk.cms.listCollections({ tenantId: "t-demo" });
+    assert.deepEqual(result, { collections: [] });
+    assert.deepEqual(calls, [
+        "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/cms/collections?tenant_id=t-demo"
+    ]);
+});
+test("runtime cms client forwards featured query when listing items", async () => {
+    const calls = [];
+    const sdk = new PlatformRuntimeSdk({
+        baseUrl: "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/",
+        appId: "app-demo",
+        fetchImpl: async (input) => {
+            const url = String(input);
+            calls.push(url);
+            if (url ===
+                "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/cms/collections/article/items?tenant_id=t-demo&page=1&page_size=10&featured=true") {
+                return new Response(JSON.stringify({ items: [], page: 1, page_size: 10, total: 0 }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    const result = await sdk.cms.listItems({
+        tenantId: "t-demo",
+        collection: "article",
+        page: 1,
+        pageSize: 10,
+        featured: true
+    });
+    assert.deepEqual(result, { items: [], page: 1, page_size: 10, total: 0 });
+    assert.deepEqual(calls, [
+        "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/cms/collections/article/items?tenant_id=t-demo&page=1&page_size=10&featured=true"
+    ]);
+});

package/runtime-sdk/dist/cms/media.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeCmsImageSet, RuntimeCmsItemDeliveryPayload } from "../types/cms.js";
+export type RuntimeCmsMediaUrlOptions = {
+    upgradeInsecureHttp?: boolean;
+    currentProtocol?: string | null;
+};
+export declare function resolveCmsImageSet(value: unknown, options?: RuntimeCmsMediaUrlOptions): RuntimeCmsImageSet | null;
+export declare function resolveCmsImageUrl(value: unknown, options?: RuntimeCmsMediaUrlOptions): string | null;
+export declare function resolveCmsCoverImageSet(item: RuntimeCmsItemDeliveryPayload, options?: RuntimeCmsMediaUrlOptions): RuntimeCmsImageSet | null;
+export declare function resolveCmsCoverImageUrl(item: RuntimeCmsItemDeliveryPayload, options?: RuntimeCmsMediaUrlOptions): string | null;
+export declare function normalizeCmsMediaUrl(value: unknown, options?: RuntimeCmsMediaUrlOptions): string | null;

package/runtime-sdk/dist/cms/media.js

@@ -0,0 +1,113 @@
+const CMS_COVER_FIELD_NAMES = ["cover", "cover_image", "hero_image", "thumbnail", "image"];
+export function resolveCmsImageSet(value, options = {}) {
+    const stringValue = asNonEmptyString(value);
+    if (stringValue) {
+        return buildImageSet({
+            original: normalizeCmsMediaUrl(stringValue, options),
+            thumbnail: null,
+            sm: null,
+            md: null,
+            lg: null
+        });
+    }
+    const record = asObjectRecord(value);
+    if (!record) {
+        return null;
+    }
+    const nestedCoverUrls = resolveCmsImageSet(record.cover_urls, options);
+    if (nestedCoverUrls) {
+        return nestedCoverUrls;
+    }
+    const variantRecord = asObjectRecord(record.variant_urls);
+    return buildImageSet({
+        original: normalizeCmsMediaUrl(asNonEmptyString(record.original_url) ?? asNonEmptyString(record.url), options),
+        thumbnail: normalizeCmsMediaUrl(asVariantString(variantRecord, "thumbnail"), options),
+        sm: normalizeCmsMediaUrl(asVariantString(variantRecord, "sm"), options),
+        md: normalizeCmsMediaUrl(asVariantString(variantRecord, "md"), options),
+        lg: normalizeCmsMediaUrl(asVariantString(variantRecord, "lg"), options)
+    });
+}
+export function resolveCmsImageUrl(value, options = {}) {
+    const imageSet = resolveCmsImageSet(value, options);
+    return pickPreferredImageUrl(imageSet);
+}
+export function resolveCmsCoverImageSet(item, options = {}) {
+    const presentationSet = resolveCmsImageSet(item.presentation?.cover_urls, options);
+    if (presentationSet) {
+        return presentationSet;
+    }
+    for (const fieldName of CMS_COVER_FIELD_NAMES) {
+        const fieldSet = resolveCmsImageSet(item.content[fieldName], options);
+        if (fieldSet) {
+            return fieldSet;
+        }
+    }
+    const presentationUrl = normalizeCmsMediaUrl(item.presentation?.cover_url, options);
+    if (!presentationUrl) {
+        return null;
+    }
+    return {
+        original: presentationUrl,
+        thumbnail: null,
+        sm: null,
+        md: null,
+        lg: null
+    };
+}
+export function resolveCmsCoverImageUrl(item, options = {}) {
+    const presentationUrl = normalizeCmsMediaUrl(item.presentation?.cover_url, options);
+    if (presentationUrl) {
+        return presentationUrl;
+    }
+    return resolveCmsImageUrl(item.presentation?.cover_urls, options) ?? resolveCmsImageUrlFromContent(item, options);
+}
+export function normalizeCmsMediaUrl(value, options = {}) {
+    const normalized = asNonEmptyString(value);
+    if (!normalized) {
+        return null;
+    }
+    if (!shouldUpgradeInsecureHttp(options) || !normalized.startsWith("http://")) {
+        return normalized;
+    }
+    return `https://${normalized.slice("http://".length)}`;
+}
+function resolveCmsImageUrlFromContent(item, options) {
+    for (const fieldName of CMS_COVER_FIELD_NAMES) {
+        const fieldUrl = resolveCmsImageUrl(item.content[fieldName], options);
+        if (fieldUrl) {
+            return fieldUrl;
+        }
+    }
+    return null;
+}
+function pickPreferredImageUrl(imageSet) {
+    if (!imageSet) {
+        return null;
+    }
+    return imageSet.md ?? imageSet.lg ?? imageSet.sm ?? imageSet.thumbnail ?? imageSet.original ?? null;
+}
+function buildImageSet(imageSet) {
+    if (!imageSet.original && !imageSet.thumbnail && !imageSet.sm && !imageSet.md && !imageSet.lg) {
+        return null;
+    }
+    return imageSet;
+}
+function shouldUpgradeInsecureHttp(options) {
+    if (options.upgradeInsecureHttp != null) {
+        return options.upgradeInsecureHttp;
+    }
+    return options.currentProtocol === "https:";
+}
+function asObjectRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asVariantString(record, key) {
+    return record ? asNonEmptyString(record[key]) : null;
+}
+function asNonEmptyString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : null;
+}

package/runtime-sdk/dist/cms/media.test.d.ts

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

package/runtime-sdk/dist/cms/media.test.js

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { normalizeCmsMediaUrl, resolveCmsCoverImageSet, resolveCmsCoverImageUrl, resolveCmsImageSet, resolveCmsImageUrl } from "./media.js";
+test("resolveCmsImageUrl prefers md variant and upgrades insecure http on https pages", () => {
+    const url = resolveCmsImageUrl({
+        original_url: "http://assets.example.com/original.jpg",
+        variant_urls: {
+            thumbnail: "http://assets.example.com/thumbnail.jpg",
+            md: "http://assets.example.com/md.jpg",
+            lg: "http://assets.example.com/lg.jpg"
+        }
+    }, { currentProtocol: "https:" });
+    assert.equal(url, "https://assets.example.com/md.jpg");
+});
+test("resolveCmsImageSet supports direct string values", () => {
+    assert.deepEqual(resolveCmsImageSet("http://assets.example.com/file.jpg"), {
+        original: "http://assets.example.com/file.jpg",
+        thumbnail: null,
+        sm: null,
+        md: null,
+        lg: null
+    });
+});
+test("resolveCmsCoverImageUrl prefers presentation cover_url before nested content fields", () => {
+    const item = buildItem({
+        presentation: {
+            cover_url: "http://assets.example.com/presentation-md.jpg",
+            cover_urls: {
+                original: "http://assets.example.com/presentation-original.jpg",
+                lg: "http://assets.example.com/presentation-lg.jpg"
+            }
+        },
+        content: {
+            cover: {
+                original_url: "http://assets.example.com/content-original.jpg",
+                variant_urls: {
+                    md: "http://assets.example.com/content-md.jpg"
+                }
+            }
+        }
+    });
+    assert.equal(resolveCmsCoverImageUrl(item, { currentProtocol: "https:" }), "https://assets.example.com/presentation-md.jpg");
+});
+test("resolveCmsCoverImageSet falls back to nested cover field when presentation is absent", () => {
+    const item = buildItem({
+        content: {
+            cover: {
+                original_url: "http://assets.example.com/content-original.jpg",
+                variant_urls: {
+                    thumbnail: "http://assets.example.com/content-thumbnail.jpg",
+                    md: "http://assets.example.com/content-md.jpg"
+                }
+            }
+        }
+    });
+    assert.deepEqual(resolveCmsCoverImageSet(item, { upgradeInsecureHttp: true }), {
+        original: "https://assets.example.com/content-original.jpg",
+        thumbnail: "https://assets.example.com/content-thumbnail.jpg",
+        sm: null,
+        md: "https://assets.example.com/content-md.jpg",
+        lg: null
+    });
+});
+test("normalizeCmsMediaUrl upgrades only insecure http", () => {
+    assert.equal(normalizeCmsMediaUrl("http://assets.example.com/a.jpg", { upgradeInsecureHttp: true }), "https://assets.example.com/a.jpg");
+    assert.equal(normalizeCmsMediaUrl("https://assets.example.com/a.jpg", { upgradeInsecureHttp: true }), "https://assets.example.com/a.jpg");
+    assert.equal(normalizeCmsMediaUrl("/relative/path.jpg", { upgradeInsecureHttp: true }), "/relative/path.jpg");
+});
+function buildItem(overrides) {
+    return {
+        collection: "articles",
+        system: {},
+        content: {},
+        ...overrides
+    };
+}

package/runtime-sdk/dist/cms/taxonomy.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimeCmsCategoryNode, RuntimeCmsCollectionMetaResponse, RuntimeCmsItemDeliveryPayload } from "../types/cms.js";
+type RuntimeCmsCategoryLookupSource = RuntimeCmsCollectionMetaResponse | RuntimeCmsCategoryNode[] | Map<string, string> | null | undefined;
+export declare function buildCmsCategoryNameMap(source: RuntimeCmsCategoryLookupSource): Map<string, string>;
+export declare function resolveCmsCategoryName(categoryId: unknown, source: RuntimeCmsCategoryLookupSource, fallback?: string): string;
+export declare function resolveCmsItemCategoryName(item: RuntimeCmsItemDeliveryPayload, source: RuntimeCmsCategoryLookupSource, fallback?: string): string;
+export declare function resolveCmsTagLabels(value: unknown): string[];
+export declare function resolveCmsItemTagLabels(item: RuntimeCmsItemDeliveryPayload): string[];
+export {};

package/runtime-sdk/dist/cms/taxonomy.js

@@ -0,0 +1,77 @@
+export function buildCmsCategoryNameMap(source) {
+    if (source instanceof Map) {
+        return source;
+    }
+    const map = new Map();
+    for (const category of getCategoryNodes(source)) {
+        const id = asNonEmptyString(category?.id);
+        if (!id) {
+            continue;
+        }
+        map.set(id, asNonEmptyString(category?.name) ?? id);
+    }
+    return map;
+}
+export function resolveCmsCategoryName(categoryId, source, fallback = "未分类") {
+    const normalizedCategoryId = asNonEmptyString(categoryId);
+    if (!normalizedCategoryId) {
+        return fallback;
+    }
+    return buildCmsCategoryNameMap(source).get(normalizedCategoryId) ?? normalizedCategoryId;
+}
+export function resolveCmsItemCategoryName(item, source, fallback = "未分类") {
+    return resolveCmsCategoryName(item?.system?.category_id, source, fallback);
+}
+export function resolveCmsTagLabels(value) {
+    const labels = [];
+    const seen = new Set();
+    for (const candidate of getTagCandidates(value)) {
+        const normalized = asNonEmptyString(candidate);
+        if (!normalized) {
+            continue;
+        }
+        const label = humanizeTagLabel(normalized);
+        const dedupeKey = label.toLocaleLowerCase();
+        if (seen.has(dedupeKey)) {
+            continue;
+        }
+        seen.add(dedupeKey);
+        labels.push(label);
+    }
+    return labels;
+}
+export function resolveCmsItemTagLabels(item) {
+    return resolveCmsTagLabels(item?.system?.tags);
+}
+function getCategoryNodes(source) {
+    if (source instanceof Map) {
+        return [];
+    }
+    if (Array.isArray(source)) {
+        return source;
+    }
+    return Array.isArray(source?.categories) ? source.categories : [];
+}
+function getTagCandidates(value) {
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => getTagCandidates(item));
+    }
+    const normalized = asNonEmptyString(value);
+    if (!normalized) {
+        return [];
+    }
+    return normalized
+        .split(/[,\n，|]+/g)
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function humanizeTagLabel(value) {
+    return value.replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function asNonEmptyString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : null;
+}

package/runtime-sdk/dist/cms/taxonomy.test.d.ts

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

package/runtime-sdk/dist/cms/taxonomy.test.js

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { buildCmsCategoryNameMap, resolveCmsCategoryName, resolveCmsItemCategoryName, resolveCmsItemTagLabels, resolveCmsTagLabels } from "./taxonomy.js";
+test("buildCmsCategoryNameMap accepts collection meta and keeps id fallback", () => {
+    const meta = {
+        collection: "article",
+        label: "Article",
+        template: "article",
+        published_item_count: 2,
+        schema: {
+            schema_version: "1",
+            kind: "collection",
+            name: "article",
+            label: "Article",
+            description: "",
+            template: "article",
+            capabilities: {},
+            fields: []
+        },
+        categories: [
+            buildCategory({ id: "cat-a", name: "设计资讯" }),
+            buildCategory({ id: "cat-b", name: "" })
+        ]
+    };
+    assert.deepEqual(Array.from(buildCmsCategoryNameMap(meta).entries()), [
+        ["cat-a", "设计资讯"],
+        ["cat-b", "cat-b"]
+    ]);
+});
+test("resolveCmsItemCategoryName falls back to category id or default label", () => {
+    const categories = [buildCategory({ id: "cat-a", name: "设计资讯" })];
+    assert.equal(resolveCmsCategoryName("cat-a", categories), "设计资讯");
+    assert.equal(resolveCmsCategoryName("cat-missing", categories), "cat-missing");
+    assert.equal(resolveCmsItemCategoryName(buildItem({ system: { category_id: null } }), categories), "未分类");
+});
+test("resolveCmsTagLabels trims, splits and humanizes tag values", () => {
+    assert.deepEqual(resolveCmsTagLabels(["featured_post", "design-news", "  Featured Post  ", "", null]), [
+        "featured post",
+        "design news"
+    ]);
+    assert.deepEqual(resolveCmsTagLabels("alpha,beta，gamma"), ["alpha", "beta", "gamma"]);
+});
+test("resolveCmsItemTagLabels returns normalized tag labels from item system", () => {
+    const labels = resolveCmsItemTagLabels(buildItem({ system: { tags: ["ui_ux", "design-news"] } }));
+    assert.deepEqual(labels, ["ui ux", "design news"]);
+});
+function buildCategory(overrides) {
+    return {
+        id: "cat-1",
+        collection: "article",
+        name: "默认分类",
+        slug: "default",
+        parent_id: null,
+        order: 0,
+        ...overrides
+    };
+}
+function buildItem(overrides) {
+    return {
+        collection: "article",
+        system: {},
+        content: {},
+        ...overrides
+    };
+}

package/runtime-sdk/dist/data-form/client.d.ts

@@ -0,0 +1,19 @@
+import type { DataFormRuntimeCreateRecordInput, DataFormRuntimeRecord, DataFormRuntimeRecordListResponse, DataFormRuntimeResourceListResponse, DataFormRuntimeSchemaResponse, DataFormRuntimeUpdateRecordInput } from "./types.js";
+import { BaseRuntimeSdk, type RuntimeSdkOptions } from "../http.js";
+export declare class RuntimeDataFormClient extends BaseRuntimeSdk {
+    constructor(options: RuntimeSdkOptions);
+    private resolveRuntimeEnv;
+    private withRuntimeEnv;
+    listResources(): Promise<DataFormRuntimeResourceListResponse>;
+    getSchema(resourceKey: string): Promise<DataFormRuntimeSchemaResponse>;
+    listRecords(args: {
+        resourceKey: string;
+        page?: number;
+        pageSize?: number;
+        ownerScope?: "me" | "all";
+        q?: string;
+    }): Promise<DataFormRuntimeRecordListResponse>;
+    getRecord(resourceKey: string, recordId: string): Promise<DataFormRuntimeRecord>;
+    createRecord(resourceKey: string, input: DataFormRuntimeCreateRecordInput): Promise<DataFormRuntimeRecord>;
+    updateRecord(resourceKey: string, recordId: string, input: DataFormRuntimeUpdateRecordInput): Promise<DataFormRuntimeRecord>;
+}