@chengxianglibra/dsh-data-analysis 0.1.2 → 0.2.1

package/lib/report-publishing/config.js

@@ -0,0 +1,69 @@
+import { isCredentialRefName } from '@deepseek-ai/dsh-credentials';
+import { z } from 'zod';
+const reference = z.string().refine(isCredentialRefName);
+const url = z
+    .string()
+    .url()
+    .refine((value) => {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return false;
+    }
+    return (['http:', 'https:'].includes(parsed.protocol) &&
+        !parsed.username &&
+        !parsed.password &&
+        !parsed.search &&
+        !parsed.hash);
+});
+export const publishingConfigSchema = z
+    .object({
+    enabled: z.boolean().default(false),
+    storage: z
+        .object({
+        name: z.string().min(1).max(100),
+        protocol: z.literal('s3').default('s3'),
+        endpoint: url,
+        region: z.string().min(1),
+        bucket: z
+            .string()
+            .min(1)
+            .max(255)
+            .regex(/^[a-zA-Z0-9][a-zA-Z0-9.-]*$/),
+        forcePathStyle: z.boolean().default(false),
+        accessKeyIdRef: reference,
+        secretAccessKeyRef: reference,
+        sessionTokenRef: reference.optional(),
+    })
+        .strict(),
+    pathPrefix: z
+        .string()
+        .default('reports')
+        .refine((value) => value === '' ||
+        value.split('/').every((part) => /^[a-zA-Z0-9_-][a-zA-Z0-9._-]*$/.test(part))),
+    publicBaseUrl: url,
+})
+    .strict()
+    .superRefine((config, ctx) => {
+    const refs = [
+        config.storage.accessKeyIdRef,
+        config.storage.secretAccessKeyRef,
+        config.storage.sessionTokenRef,
+    ].filter(Boolean);
+    if (new Set(refs).size !== refs.length)
+        ctx.addIssue({ code: 'custom', message: 'distinct-credential-references-required' });
+});
+export function resolvePublishingConfig(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('report-publishing-config-invalid');
+    if (value.enabled === false || value.enabled === undefined)
+        return undefined;
+    const result = publishingConfigSchema.safeParse(value);
+    if (!result.success)
+        throw new Error('report-publishing-config-invalid');
+    return result.data;
+}

package/lib/report-publishing/service.js

@@ -0,0 +1,180 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { credentialRef } from '@deepseek-ai/dsh-credentials';
+import { PRESENTATION_BUDGETS } from "../presentation/contracts/index.js";
+export function publishingPathName(value, fallback) {
+    const name = Array.from(value.normalize('NFKC').replace(/[^\p{L}\p{N}_-]+/gu, '-'))
+        .slice(0, 48)
+        .join('')
+        .replace(/^-+|-+$/g, '');
+    return name || fallback;
+}
+export async function uploadReport(input) {
+    const { config, credentials, key, bytes, signal } = input;
+    const client = new S3Client({
+        endpoint: config.storage.endpoint,
+        region: config.storage.region,
+        forcePathStyle: config.storage.forcePathStyle,
+        credentials,
+        maxAttempts: 3,
+        requestChecksumCalculation: 'WHEN_REQUIRED',
+    });
+    try {
+        await client.send(new PutObjectCommand({
+            Bucket: config.storage.bucket,
+            Key: key,
+            Body: bytes,
+            ContentType: 'text/html; charset=utf-8',
+            ContentDisposition: 'inline',
+            CacheControl: 'public, max-age=31536000, immutable',
+        }), { abortSignal: signal });
+    }
+    finally {
+        client.destroy();
+    }
+}
+export class ReportPublishingService {
+    configId = randomUUID();
+    config;
+    store;
+    files;
+    upload;
+    workspaceName;
+    constructor(config, store, files, upload = uploadReport, workspaceName = () => 'workspace') {
+        this.workspaceName = workspaceName;
+        this.config = config
+            ? Object.freeze({ ...config, storage: Object.freeze({ ...config.storage }) })
+            : undefined;
+        this.store = store;
+        this.files = files;
+        this.upload = upload;
+    }
+    assertConfig(configId) {
+        if (configId !== this.configId)
+            throw new Error('report-publishing-config-changed');
+    }
+    references() {
+        const storage = this.config?.storage;
+        if (!storage)
+            return [];
+        return [
+            { field: 'accessKeyId', reference: storage.accessKeyIdRef, required: true },
+            { field: 'secretAccessKey', reference: storage.secretAccessKeyRef, required: true },
+            ...(storage.sessionTokenRef
+                ? [{ field: 'sessionToken', reference: storage.sessionTokenRef, required: true }]
+                : []),
+        ];
+    }
+    async describe() {
+        if (!this.config)
+            return { enabled: false, fields: [] };
+        const fields = await Promise.all(this.references().map(async (field) => {
+            const info = await this.store.describe(credentialRef(field.reference));
+            return {
+                ...field,
+                configured: info.configured,
+                writable: info.writable,
+                ...(info.source ? { source: info.source } : {}),
+            };
+        }));
+        return {
+            enabled: true,
+            configId: this.configId,
+            name: this.config.storage.name,
+            bucket: this.config.storage.bucket,
+            fields,
+        };
+    }
+    async change(field, value, signal) {
+        const item = this.references().find((item) => item.field === field);
+        if (!item)
+            throw new Error('report-publishing-disabled-or-field-unavailable');
+        signal.throwIfAborted();
+        if (value === undefined)
+            await this.store.unset(credentialRef(item.reference));
+        else
+            await this.store.set(credentialRef(item.reference), value);
+    }
+    async publish(scope, reportId, buildId, signal, viewHtml) {
+        const config = this.config;
+        if (!config)
+            throw new Error('report-publishing-disabled');
+        const history = await this.files.catalog('reports/history', { ...scope, reportId }, signal);
+        if (!('versions' in history))
+            throw new Error('report-publishing-build-unavailable');
+        const receipt = history.versions.find((entry) => entry.receipt.buildId === buildId)?.receipt;
+        if (!receipt)
+            throw new Error('report-publishing-build-unavailable');
+        const credentials = {};
+        for (const field of this.references()) {
+            signal.throwIfAborted();
+            const hit = await this.store.resolve(credentialRef(field.reference));
+            if (!hit?.value)
+                throw new Error('report-publishing-credentials-missing');
+            credentials[field.field] = hit.value;
+        }
+        const asset = await this.files.read({ ...scope, receipt, asset: viewHtml === undefined ? 'index.html' : 'presentation.json' }, signal);
+        let bytes;
+        if (viewHtml === undefined)
+            bytes = Buffer.from(asset.bodyBase64, 'base64');
+        else {
+            if (Buffer.byteLength(viewHtml) > PRESENTATION_BUDGETS.htmlBytes ||
+                !viewHtml.startsWith('<!doctype html><html lang="zh-CN"><head>'))
+                throw new Error('report-publishing-view-invalid');
+            // Browser-authored snapshot: force a restrictive policy before any client-supplied markup.
+            bytes = Buffer.from(viewHtml.replace('<head>', `<head><meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'">`));
+            if (bytes.length > PRESENTATION_BUDGETS.htmlBytes)
+                throw new Error('report-publishing-view-invalid');
+        }
+        const sha256 = createHash('sha256').update(bytes).digest('hex');
+        const identity = createHash('sha256')
+            .update(JSON.stringify([
+            receipt.workspaceId,
+            reportId,
+            buildId,
+            viewHtml === undefined ? 'report' : 'view',
+            sha256,
+        ]))
+            .digest('hex')
+            .slice(0, 32);
+        const key = [
+            config.pathPrefix,
+            publishingPathName(this.workspaceName(receipt.workspaceId), 'workspace'),
+            publishingPathName(receipt.title, 'report'),
+            identity,
+            'index.html',
+        ]
+            .filter(Boolean)
+            .join('/');
+        signal.throwIfAborted();
+        try {
+            await this.upload({
+                config,
+                credentials: credentials,
+                key,
+                bytes,
+                signal,
+            });
+        }
+        catch {
+            throw new Error('report-publishing-upload-unconfirmed');
+        }
+        finally {
+            for (const key of Object.keys(credentials))
+                delete credentials[key];
+        }
+        return {
+            storage: config.storage.name,
+            bucket: config.storage.bucket,
+            key,
+            url: `${config.publicBaseUrl.replace(/\/+$/, '')}/${key.split('/').map(encodeURIComponent).join('/')}`,
+            workspaceId: receipt.workspaceId,
+            reportId,
+            buildId,
+            sha256,
+            bytes: bytes.length,
+            kind: viewHtml === undefined ? 'report' : 'view',
+            publishedAt: new Date().toISOString(),
+        };
+    }
+}

package/lib/rpc.js

@@ -0,0 +1,49 @@
+/** Dedicated plugin RPC envelopes over Harness-owned authenticated exact Fetch routes. */
+import { clientRequestSchema, } from '@deepseek-ai/dsh-client-connection';
+import { finishCleanup, PendingTasks } from "./lifecycle.js";
+export function registerPluginRpc(connection, channel, endpoints, handler) {
+    const lifetime = new AbortController();
+    const tasks = new PendingTasks();
+    let closing;
+    const disposers = [];
+    const close = () => {
+        if (closing)
+            return closing;
+        lifetime.abort();
+        closing = finishCleanup([...disposers.reverse(), () => tasks.drain()]);
+        return closing;
+    };
+    try {
+        for (const endpoint of endpoints) {
+            const method = `${channel.slice(1)}/${endpoint}`;
+            disposers.push(connection.fetch.register({
+                path: `/api/${method}`,
+                methods: ['POST'],
+                requestBody: 'buffered',
+                fetch(request) {
+                    if (lifetime.signal.aborted)
+                        return Promise.resolve(new Response('Plugin disposed', { status: 503 }));
+                    return tasks.track((async () => {
+                        if (request.headers.get('content-type')?.split(';')[0]?.trim().toLowerCase() !==
+                            'application/json')
+                            return new Response('Expected application/json', { status: 415 });
+                        const body = await request.json().catch(() => undefined);
+                        const parsed = clientRequestSchema.safeParse(body);
+                        if (!parsed.success || parsed.data.method !== method)
+                            return new Response('Invalid plugin request', { status: 400 });
+                        // A request admitted before withdrawal may still be decoding its body.
+                        if (lifetime.signal.aborted)
+                            return new Response('Plugin disposed', { status: 503 });
+                        const result = await handler(endpoint, parsed.data.payload, AbortSignal.any([request.signal, lifetime.signal]));
+                        return Response.json({ type: 'server-response', rpcId: parsed.data.rpcId, result });
+                    })());
+                },
+            }));
+        }
+    }
+    catch (error) {
+        void close();
+        throw error;
+    }
+    return close;
+}

package/lib/semantic-browser/contracts.js

@@ -2,6 +2,8 @@ import { boundedText, closed, parseRef, refKey, } from "../semantic-reference/co
 import { parseComputation } from "./definition.js";
 export const BROWSER_ENDPOINT = 'semantic-browser/catalog';
 export const CATALOG_MAX_BYTES = 32 * 1024 * 1024;
+export const CATALOG_ERROR_SCHEMA = 'marivo.semantic_catalog_error/v1';
+const CATALOG_ERROR_MAX_CHARS = 16 * 1024;
 function array(value, max) {
     if (!Array.isArray(value) || value.length > max)
         throw new Error('invalid-catalog');
@@ -57,6 +59,21 @@ export function parseCatalogProjection(value) {
         throw new Error('invalid-catalog');
     return { fingerprint: boundedText(r.fingerprint, 256), kinds, objects };
 }
+export function parseCatalogFailure(value) {
+    try {
+        const r = closed(value, ['schema', 'kind', 'message']);
+        if (r.schema !== CATALOG_ERROR_SCHEMA || r.kind !== 'semantic')
+            return undefined;
+        return {
+            schema: CATALOG_ERROR_SCHEMA,
+            kind: 'semantic',
+            message: boundedText(r.message, CATALOG_ERROR_MAX_CHARS),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 export function parseCatalogSnapshot(value) {
     const r = closed(value, [
         'workspaceId',

package/lib/semantic-browser/program.js

@@ -14,6 +14,7 @@ class DiscardOutput:
 with contextlib.redirect_stdout(DiscardOutput()), contextlib.redirect_stderr(DiscardOutput()):
     import marivo.semantic as ms
     from marivo.refs import Ref, RefPayloadV1, SemanticKind
+    from marivo.semantic.errors import SemanticError, SemanticLoadFailed
 
     FIELDS = {
         "domain": "owner default",
@@ -109,11 +110,20 @@ with contextlib.redirect_stdout(DiscardOutput()), contextlib.redirect_stderr(Dis
             "fields": fields, "relations": list(unique.values()),
         }
 
+try:
     catalog = ms.load(workspace_dir=sys.argv[1])
     result = {
         "fingerprint": catalog.definition_fingerprint,
         "kinds": [kind.value for kind in SemanticKind],
         "objects": [project(entry) for kind in SemanticKind for entry in catalog.items(kind).items],
     }
+except (SemanticLoadFailed, SemanticError) as error:
+    print(json.dumps({
+        "schema": "marivo.semantic_catalog_error/v1",
+        "kind": "semantic",
+        "message": str(error),
+    }, ensure_ascii=True))
+    raise SystemExit(1)
+
 print(json.dumps(result, ensure_ascii=True))
 `.trim();

package/lib/semantic-browser/service.js

@@ -1,12 +1,25 @@
 import { realpath } from 'node:fs/promises';
+import { finishCleanup, PendingTasks } from "../lifecycle.js";
 import { boundedText, closed } from "../semantic-reference/contracts.js";
+import { semanticEnvironmentFingerprint } from "../semantic-reference/environment.js";
 import { abortable } from "../semantic-reference/rpc.js";
-import { CATALOG_MAX_BYTES, parseCatalogProjection } from "./contracts.js";
+import { CATALOG_MAX_BYTES, parseCatalogFailure, parseCatalogProjection, } from "./contracts.js";
 import { BROWSER_CATALOG_PROGRAM } from "./program.js";
+export class SemanticCatalogLoadError extends Error {
+    code = 'catalog-load-failed';
+    diagnostic;
+    constructor(diagnostic) {
+        super(diagnostic);
+        this.diagnostic = diagnostic;
+        this.name = 'SemanticCatalogLoadError';
+    }
+}
 /** Workspace-addressed read service; intentionally has no Agent or credential dependency. */
 export class SemanticBrowserService {
     #host;
     #lifetime = new AbortController();
+    #tasks = new PendingTasks();
+    #closing;
     constructor(host) {
         this.#host = host;
     }
@@ -15,7 +28,10 @@ export class SemanticBrowserService {
         if (!current || current.path !== workspacePath || this.#host.projectRoot(current) !== root)
             throw new Error('workspace-changed');
     }
-    async read(payload, caller) {
+    read(payload, caller) {
+        return this.#tasks.track(this.#read(payload, caller));
+    }
+    async #read(payload, caller) {
         const signal = AbortSignal.any([caller, this.#lifetime.signal]);
         signal.throwIfAborted();
         const request = closed(payload, ['workspaceId']);
@@ -24,7 +40,7 @@ export class SemanticBrowserService {
         if (!workspace)
             throw new Error('workspace-unavailable');
         const root = this.#host.projectRoot(workspace);
-        const runner = await abortable(this.#host.resolve(root), signal);
+        const runner = await abortable(this.#tasks.track(this.#host.resolve(root)), signal);
         this.#assertOwner(id, workspace.path, root);
         if (runner.status !== 'ready')
             throw new Error('environment-failed');
@@ -40,8 +56,19 @@ export class SemanticBrowserService {
             throw new Error('workspace-changed');
         this.#assertOwner(id, workspace.path, root);
         signal.throwIfAborted();
-        if (result.exitCode !== 0)
+        if (result.exitCode !== 0) {
+            const failure = (() => {
+                try {
+                    return parseCatalogFailure(JSON.parse(result.stdout.toString('utf8')));
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            if (failure)
+                throw new SemanticCatalogLoadError(failure.message);
             throw new Error('catalog-load-failed');
+        }
         if (result.stdout.byteLength > CATALOG_MAX_BYTES)
             throw new Error('catalog-too-large');
         const projection = parseCatalogProjection(JSON.parse(result.stdout.toString('utf8')));
@@ -49,17 +76,24 @@ export class SemanticBrowserService {
             ...projection,
             workspaceId: id,
             projectRoot: runner.binding.projectRoot,
-            environmentFingerprint: runner.binding.fingerprint,
+            environmentFingerprint: semanticEnvironmentFingerprint(id, runner.binding.fingerprint),
             loadedAt: new Date().toISOString(),
         };
     }
+    close() {
+        this.dispose();
+        this.#closing ??= finishCleanup([() => this.#tasks.drain()]);
+        return this.#closing;
+    }
     dispose() {
         this.#lifetime.abort();
     }
 }
-/** Fixed diagnostics only: Python errors may contain model code or datasource secrets. */
+/** Preserve Marivo semantic diagnostics; keep unknown Python failures behind a fixed fallback. */
 export function browserFailure(error) {
     const code = error instanceof Error && 'code' in error ? error.code : undefined;
+    if (error instanceof SemanticCatalogLoadError)
+        return `语义层模型加载失败：\n${error.diagnostic}`;
     if (code === 'subprocess-timeout')
         return '语义层加载超时，请检查模型后重试。';
     if (code === 'subprocess-output-limit' ||

package/lib/semantic-reference/bridge.js

@@ -1,3 +1,4 @@
+import { finishCleanup, PendingTasks } from "../lifecycle.js";
 import { parseProjection } from "./contracts.js";
 export const CATALOG_PROGRAM = String.raw `
 import contextlib, io, json, sys
@@ -19,6 +20,8 @@ export class SemanticReferenceBridge {
     #slots = new Map();
     #clock;
     #disposed = false;
+    #tasks = new PendingTasks();
+    #closing;
     constructor(clock = Date.now) {
         this.#clock = clock;
     }
@@ -47,7 +50,8 @@ export class SemanticReferenceBridge {
                 promise: Promise.resolve({ kinds: [], items: [] }),
             };
             current.flight = flight;
-            flight.promise = this.#load(runner, controller.signal)
+            flight.promise = this.#tasks
+                .track(this.#load(runner, controller.signal))
                 .then((projection) => {
                 if (!controller.signal.aborted &&
                     !this.#disposed &&
@@ -105,6 +109,11 @@ export class SemanticReferenceBridge {
             throw new Error('catalog-load-failed');
         return parseProjection(JSON.parse(result.stdout.toString('utf8')));
     }
+    close() {
+        this.dispose();
+        this.#closing ??= finishCleanup([() => this.#tasks.drain()]);
+        return this.#closing;
+    }
     invalidate(key) {
         const slot = this.#slots.get(key);
         this.#slots.delete(key);

package/lib/semantic-reference/contracts.js

@@ -1,7 +1,6 @@
 /** Browser-safe wire contracts. These bounds do not reimplement Marivo's domain grammar. */
 export const CHANNEL = '/dsh-data-analysis';
 export const SOURCE = 'marivo-semantic';
-export const LIMIT = 40;
 export const MAX_WIRE_BYTES = 1024 * 1024;
 export function closed(value, keys) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
@@ -87,20 +86,19 @@ export function parseProjection(value) {
     return Object.freeze({ kinds: Object.freeze(kinds), items: Object.freeze(items) });
 }
 export function parseCandidatesRequest(value) {
-    const r = closed(value, ['version', 'sessionId', 'query', 'quoted', 'limit']);
-    if (r.version !== 1 || r.limit !== LIMIT || typeof r.quoted !== 'boolean')
+    const r = closed(value, ['version', 'sessionId', 'query', 'quoted']);
+    if (r.version !== 1 || typeof r.quoted !== 'boolean')
         throw new Error('invalid-request');
     return {
         version: 1,
         sessionId: boundedText(r.sessionId, 256),
         query: boundedText(r.query, 128, true),
         quoted: r.quoted,
-        limit: LIMIT,
     };
 }
 export function parseCandidatesResponse(value) {
     const r = closed(value, ['environmentFingerprint', 'items']);
-    if (!Array.isArray(r.items) || r.items.length > LIMIT)
+    if (!Array.isArray(r.items))
         throw new Error('invalid-response');
     const items = r.items.map((raw) => {
         const item = closed(raw, ['ref', 'refKey', 'name', 'businessDefinition', 'section']);
@@ -109,5 +107,21 @@ export function parseCandidatesResponse(value) {
             throw new Error('invalid-response');
         return { ...parseCandidate(candidate), section };
     });
-    return { environmentFingerprint: boundedText(r.environmentFingerprint, 256), items };
+    return {
+        environmentFingerprint: boundedText(r.environmentFingerprint, 256),
+        items,
+    };
+}
+/** Browser selection identity only; preparation never reloads semantic content. */
+export function parsePrepareRequest(value) {
+    const r = closed(value, ['sessionId', 'workspaceId', 'environmentFingerprint', 'ref']);
+    return {
+        workspaceId: boundedText(r.workspaceId, 256),
+        envelope: parseEnvelope({
+            schema: 'dsh-data-analysis-semantic-reference/v1',
+            sessionId: r.sessionId,
+            environmentFingerprint: r.environmentFingerprint,
+            ref: r.ref,
+        }),
+    };
 }

package/lib/semantic-reference/environment.js

@@ -0,0 +1,56 @@
+import { createHash } from 'node:crypto';
+/** Reference identity includes Harness ownership; the underlying Runtime stays unchanged. */
+export function semanticEnvironmentFingerprint(workspaceId, runtimeFingerprint) {
+    return createHash('sha256')
+        .update(JSON.stringify(['marivo-semantic-workspace/v1', workspaceId, runtimeFingerprint]))
+        .digest('hex');
+}
+/** Explicit selection establishes ownership; serialization never repairs it. */
+export function referenceEnvironmentResolver(host) {
+    const owners = new WeakMap();
+    return async (sessionId, purpose, workspaceId) => {
+        const agent = host.agent(sessionId);
+        if (!agent)
+            throw new Error('unknown-session');
+        const priorOwner = owners.get(agent);
+        const owner = purpose === 'reference' ? priorOwner?.workspace : host.workspace(sessionId);
+        if (purpose === 'prepare' && (!workspaceId || owner?.id !== workspaceId))
+            throw new Error('workspace-mismatch');
+        const checkOwner = () => {
+            if (!owner)
+                return;
+            const current = host.workspace(sessionId);
+            if (current.id !== owner.id || current.path !== owner.path)
+                throw new Error('workspace-changed');
+        };
+        checkOwner();
+        const bound = host.binding(agent);
+        if (purpose === 'reference' &&
+            (!owner || !bound || bound !== priorOwner?.binding || bound.root !== host.projectRoot(agent)))
+            throw new Error('environment-unbound');
+        const pending = purpose === 'reference' ? bound.environment : host.resolve(agent);
+        const expected = host.binding(agent);
+        const environment = await pending;
+        if (host.agent(sessionId) !== agent ||
+            host.binding(agent) !== expected ||
+            expected?.root !== host.projectRoot(agent))
+            throw new Error('environment-changed');
+        checkOwner();
+        if (!owner || !expected)
+            throw new Error('environment-unbound');
+        if (purpose !== 'reference')
+            owners.set(agent, { workspace: owner, binding: expected });
+        // Only the semantic surface uses the ownership fingerprint. Execution is delegated
+        // to the original runner, preserving its Runtime identity and dynamic health.
+        return {
+            binding: {
+                ...environment.binding,
+                fingerprint: semanticEnvironmentFingerprint(owner.id, environment.binding.fingerprint),
+            },
+            get status() {
+                return environment.status;
+            },
+            runChecked: (request) => environment.runChecked(request),
+        };
+    };
+}

package/lib/semantic-reference/labels.js

@@ -0,0 +1,16 @@
+/** Shared display labels and search aliases; object kinds still come from the live Catalog. */
+export const semanticKindLabels = {
+    domain: '业务域',
+    datasource: '数据源',
+    entity: '实体',
+    dimension: '维度',
+    measure: '度量',
+    time_dimension: '时间维度',
+    metric: '指标',
+    relationship: '关系',
+    event: '事件',
+    state_model: '状态模型',
+    period_calendar: '周期日历',
+    temporal_set: '时间集合',
+    work_schedule: '工作日程',
+};