@webskill/sdk 0.14.0 → 0.15.0

package/dist/{openUiLibrary-BKXW7Iwx-DjvEnMlJ.js → dist-CTsxblSD.js}

@@ -1,10 +1,7 @@
-import { Dt as uiCatalog } from "./dist-CiaDIqkV.js";
-import { t as CatalogNode } from "./catalogComponents-BgAJN0p8-Cr55ouOg.js";
-import { z } from "zod";
 import { Component, Fragment, createContext, useCallback, useContext, useEffect, useInsertionEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { object } from "zod/v4";
-import * as z$1 from "zod/v4/core";
+import * as z from "zod/v4/core";
 
 //#region ../../node_modules/.pnpm/@openuidev+lang-core@0.2.9_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__zod@4.4.3/node_modules/@openuidev/lang-core/dist/index.mjs
 /** Resolve a field path on an object. Supports dot-paths: "state.name" → obj.state.name */
@@ -655,11 +652,23 @@ function generatePrompt(spec) {
 }
 /** WeakSet tracks reactive schemas without mutating the schema objects. */
 const reactiveSchemas = /* @__PURE__ */ new WeakSet();
+/** Mark a schema as reactive. Called by framework adapters' reactive() function. */
+function markReactive(schema) {
+	reactiveSchemas.add(schema);
+}
 /** Check if a schema was marked reactive. Used by Zod introspection for $binding<> prefix. */
 function isReactiveSchema(schema) {
 	return typeof schema === "object" && schema !== null && reactiveSchemas.has(schema);
 }
 const schemaIdTags = /* @__PURE__ */ new WeakMap();
+/**
+* Tag a schema with an ID for prompt signatures.
+* Use for non-component schemas that need friendly type names (e.g. ActionExpression).
+* This affects prompt output only, not JSON Schema $defs.
+*/
+function tagSchemaId(schema, id) {
+	schemaIdTags.set(schema, id);
+}
 function assertV4Schema(schema, componentName) {
 	if (schema != null && typeof schema === "object" && "_def" in schema && !("_zod" in schema)) throw new Error(`[OpenUI] Component "${componentName}" was defined with a Zod 3 schema. OpenUI requires Zod 4 schemas. If you're on zod@3.25+, import from "zod/v4" instead of "zod". See: https://zod.dev/v4/versioning`);
 }
@@ -803,7 +812,7 @@ function buildComponentSpecs(components, reg) {
 */
 function createLibrary$1(input) {
 	const componentsRecord = {};
-	const reg = z$1.registry();
+	const reg = z.registry();
 	for (const comp of input.components) {
 		reg.add(comp.props, { id: comp.name });
 		componentsRecord[comp.name] = comp;
@@ -840,7 +849,7 @@ function createLibrary$1(input) {
 	};
 	function buildJSONSchema() {
 		const combinedSchema = object(Object.fromEntries(Object.entries(componentsRecord).map(([k, v]) => [k, v.props])));
-		const schema = z$1.toJSONSchema(combinedSchema, { metadata: reg });
+		const schema = z.toJSONSchema(combinedSchema, { metadata: reg });
 		for (const [name, comp] of Object.entries(componentsRecord)) {
 			const def = schema.$defs?.[name];
 			if (def && comp.description) def.description = comp.description;
@@ -2204,6 +2213,28 @@ function stripComments(input) {
 function preprocess(input) {
 	return stripComments(stripFences(input.trim())).trim();
 }
+/**
+* Parse a complete openui-lang string in one pass.
+*
+* @param input  - Full openui-lang source text (may be partial/streaming)
+* @param cat    - Param map for positional-arg → named-prop mapping
+* @returns      ParseResult with root ElementNode (or null) and metadata
+*/
+function parse(input, cat, rootName) {
+	const trimmed = preprocess(input);
+	if (!trimmed) return emptyResult();
+	const { text, wasIncomplete } = autoClose(trimmed);
+	const stmts = split(tokenize(text));
+	if (!stmts.length) return emptyResult(wasIncomplete);
+	const stmtMap = /* @__PURE__ */ new Map();
+	let firstId = "";
+	for (const s of stmts) {
+		const stmt = classifyStatement(s, parseExpression(s.tokens));
+		stmtMap.set(s.id, stmt);
+		if (!firstId) firstId = s.id;
+	}
+	return buildResult(stmtMap, [...stmtMap.values()], firstId, wasIncomplete, stmtMap.size, cat, rootName);
+}
 function createStreamParser(cat, rootName) {
 	let buf = "";
 	let cleaned = "";
@@ -2332,6 +2363,22 @@ function compileSchema(schema) {
 	return map;
 }
 /**
+* Create a parser from a library JSON Schema document.
+* Pass `library.toJSONSchema()` to get the schema.
+*
+* @example
+* ```ts
+* const parser = createParser(library.toJSONSchema());
+* const result = parser.parse(openuiLangString);
+* ```
+*/
+function createParser(schema, rootName) {
+	const paramMap = compileSchema(schema);
+	return { parse(input) {
+		return parse(input, paramMap, rootName);
+	} };
+}
+/**
 * Create a streaming parser from a library JSON Schema document.
 * Pass `library.toJSONSchema()` to get the schema.
 */
@@ -2365,6 +2412,126 @@ function enrichErrors(validationErrors, schema, componentNames) {
 		return error;
 	});
 }
+function splitStatementSource(input) {
+	const stmts = [];
+	let depth = 0;
+	let inStr = false;
+	let esc = false;
+	let start = 0;
+	for (let i = 0; i < input.length; i++) {
+		const c = input[i];
+		if (esc) {
+			esc = false;
+			continue;
+		}
+		if (c === "\\" && inStr) {
+			esc = true;
+			continue;
+		}
+		if (inStr) {
+			if (c === inStr) inStr = false;
+			continue;
+		}
+		if (c === "\"" || c === "'") {
+			inStr = c;
+			continue;
+		}
+		if (c === "(" || c === "[" || c === "{") depth++;
+		else if (c === ")" || c === "]" || c === "}") depth = Math.max(0, depth - 1);
+		else if (c === "\n" && depth <= 0) {
+			const stmt = input.slice(start, i).trim();
+			if (stmt) stmts.push(stmt);
+			start = i + 1;
+		}
+	}
+	const tail = input.slice(start).trim();
+	if (tail) stmts.push(tail);
+	return stmts;
+}
+function parseStatements(input) {
+	const trimmed = input.trim();
+	if (!trimmed) return [];
+	const result = [];
+	for (const raw of splitStatementSource(trimmed)) {
+		const stmt = split(tokenize(raw))[0];
+		if (!stmt) continue;
+		result.push({
+			id: stmt.id,
+			ast: parseExpression(stmt.tokens),
+			raw
+		});
+	}
+	return result;
+}
+/**
+* Recursively collect all Ref names from an AST node.
+*/
+function collectRefs(node, out) {
+	walkAST(node, (current) => {
+		if (current.k === "Ref") out.add(current.n);
+		if (current.k === "RuntimeRef") out.add(current.n);
+	});
+}
+/**
+* Remove statements unreachable from `root` (garbage collection).
+* Walks the AST graph from root, collecting all referenced statement IDs.
+* $state variables are always kept (they're referenced at runtime, not by Ref nodes).
+*/
+function gcUnreachable(order, merged, asts, rootId = "root") {
+	if (!asts.get(rootId)) return;
+	const reachable = /* @__PURE__ */ new Set([rootId]);
+	const queue = [rootId];
+	while (queue.length > 0) {
+		const id = queue.pop();
+		const ast = asts.get(id);
+		if (!ast) continue;
+		const refs = /* @__PURE__ */ new Set();
+		collectRefs(ast, refs);
+		for (const ref of refs) if (!reachable.has(ref) && asts.has(ref)) {
+			reachable.add(ref);
+			queue.push(ref);
+		}
+	}
+	for (const id of order) if (id.startsWith("$")) reachable.add(id);
+	for (let i = order.length - 1; i >= 0; i--) if (!reachable.has(order[i])) {
+		merged.delete(order[i]);
+		order.splice(i, 1);
+	}
+}
+/**
+* Merge an existing program with a patch (partial update).
+* Patch statements override existing ones by name.
+* Unreachable statements are automatically garbage-collected.
+* Returns the merged program as a string.
+*/
+function mergeStatements(existing, patch, rootId = "root") {
+	const existingStmts = parseStatements(existing);
+	const patchStmts = parseStatements(stripFences(patch));
+	if (!existingStmts.length) return patchStmts.map((stmt) => stmt.raw).join("\n");
+	if (!patchStmts.length) return existing;
+	const merged = /* @__PURE__ */ new Map();
+	const asts = /* @__PURE__ */ new Map();
+	const order = [];
+	for (const stmt of existingStmts) {
+		merged.set(stmt.id, stmt.raw);
+		asts.set(stmt.id, stmt.ast);
+		order.push(stmt.id);
+	}
+	for (const stmt of patchStmts) {
+		if (stmt.ast.k === "Null") {
+			merged.delete(stmt.id);
+			asts.delete(stmt.id);
+			const idx = order.indexOf(stmt.id);
+			if (idx !== -1) order.splice(idx, 1);
+			continue;
+		}
+		if (!merged.has(stmt.id)) order.push(stmt.id);
+		merged.set(stmt.id, stmt.raw);
+		asts.set(stmt.id, stmt.ast);
+	}
+	gcUnreachable(order, merged, asts, rootId);
+	return order.filter((id) => merged.has(id)).map((id) => merged.get(id)).join("\n");
+}
 function isReactiveAssign(value) {
 	return typeof value === "object" && value !== null && value.__reactive === "assign";
 }
@@ -3199,6 +3366,30 @@ function createQueryManager(toolProvider) {
 		dispose
 	};
 }
+function resolveStateField(name, bindingValue, store, evaluationContext, fieldGetter, fieldSetter) {
+	if (isReactiveAssign(bindingValue) && store && evaluationContext) {
+		const { target, expr } = bindingValue;
+		return {
+			name,
+			value: store.get(target),
+			setValue: (value) => {
+				const extraScope = { $value: value };
+				const nextValue = evaluate(expr, {
+					...evaluationContext,
+					extraScope
+				});
+				store.set(target, nextValue);
+			},
+			isReactive: true
+		};
+	}
+	return {
+		name,
+		value: fieldGetter(name) ?? bindingValue,
+		setValue: (value) => fieldSetter(name, value),
+		isReactive: false
+	};
+}
 function createStore() {
 	const state = /* @__PURE__ */ new Map();
 	const listeners = /* @__PURE__ */ new Set();
@@ -3254,6 +3445,139 @@ function createStore() {
 		dispose
 	};
 }
+/**
+* Parse a rule string into a structured rule.
+*   "required"       → { type: "required" }
+*   "min:8"          → { type: "min", arg: 8 }
+*   "minLength:3"    → { type: "minLength", arg: 3 }
+*   "pattern:^[a-z]" → { type: "pattern", arg: "^[a-z]" }
+*/
+const NUMERIC_RULES = /* @__PURE__ */ new Set([
+	"min",
+	"max",
+	"minLength",
+	"maxLength"
+]);
+function parseRule(rule) {
+	const colonIdx = rule.indexOf(":");
+	if (colonIdx === -1) return { type: rule };
+	const type = rule.slice(0, colonIdx);
+	const rawArg = rule.slice(colonIdx + 1);
+	return {
+		type,
+		arg: NUMERIC_RULES.has(type) && !Number.isNaN(Number(rawArg)) ? Number(rawArg) : rawArg
+	};
+}
+function parseRules(rules) {
+	if (!Array.isArray(rules)) return [];
+	return rules.filter((r) => typeof r === "string").map(parseRule);
+}
+function isEmpty(value) {
+	if (value === null || value === void 0 || value === "") return true;
+	if (Array.isArray(value) && value.length === 0) return true;
+	if (value && typeof value === "object" && !Array.isArray(value) && "value" in value) return isEmpty(value.value);
+	if (typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0) return true;
+	return false;
+}
+const builtInValidators = {
+	required: (value) => {
+		if (isEmpty(value)) return "This field is required";
+		if (typeof value === "object" && !Array.isArray(value) && value !== null) {
+			const vals = Object.values(value);
+			if (vals.length > 0 && vals.every((v) => typeof v === "boolean") && !vals.some(Boolean)) return "At least one option is required";
+		}
+	},
+	email: (value) => {
+		if (isEmpty(value)) return void 0;
+		if (typeof value !== "string") return "Please enter a valid email";
+		return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) ? void 0 : "Please enter a valid email";
+	},
+	url: (value) => {
+		if (isEmpty(value)) return void 0;
+		if (typeof value !== "string") return "Please enter a valid URL";
+		try {
+			new URL(value);
+			return;
+		} catch {
+			return "Please enter a valid URL";
+		}
+	},
+	numeric: (value) => {
+		if (isEmpty(value)) return void 0;
+		if (typeof value === "number" && !isNaN(value)) return void 0;
+		if (typeof value === "string" && !isNaN(parseFloat(value)) && value.trim() !== "") return void 0;
+		return "Must be a number";
+	},
+	min: (value, arg) => {
+		if (isEmpty(value)) return void 0;
+		const n = typeof value === "number" ? value : parseFloat(String(value));
+		if (isNaN(n)) return void 0;
+		const min = Number(arg);
+		return n >= min ? void 0 : `Must be at least ${min}`;
+	},
+	max: (value, arg) => {
+		if (isEmpty(value)) return void 0;
+		const n = typeof value === "number" ? value : parseFloat(String(value));
+		if (isNaN(n)) return void 0;
+		const max = Number(arg);
+		return n <= max ? void 0 : `Must be no more than ${max}`;
+	},
+	minLength: (value, arg) => {
+		if (isEmpty(value)) return void 0;
+		if (typeof value !== "string") return void 0;
+		const min = Number(arg);
+		return value.length >= min ? void 0 : `Must be at least ${min} characters`;
+	},
+	maxLength: (value, arg) => {
+		if (isEmpty(value)) return void 0;
+		if (typeof value !== "string") return void 0;
+		const max = Number(arg);
+		return value.length <= max ? void 0 : `Must be no more than ${max} characters`;
+	},
+	pattern: (value, arg) => {
+		if (isEmpty(value)) return void 0;
+		if (typeof value !== "string" || typeof arg !== "string") return void 0;
+		try {
+			return new RegExp(arg).test(value) ? void 0 : "Invalid format";
+		} catch {
+			return;
+		}
+	}
+};
+/**
+* Run all rules against a value. Stop on first error.
+* Custom validators are checked first, then built-in ones.
+*/
+function validate(value, rules, customValidators) {
+	for (const rule of rules) {
+		const validator = customValidators?.[rule.type] ?? builtInValidators[rule.type];
+		if (!validator) {
+			console.warn(`[openui] Unknown validation rule type: "${rule.type}"`);
+			continue;
+		}
+		const error = validator(value, rule.arg);
+		if (error) return error;
+	}
+}
+/**
+* Parse a structured rules object into ParsedRule[].
+* Accepts: { required: true, minLength: 5, email: true, max: 100 }
+* Skips keys with false/undefined values.
+*/
+function parseStructuredRules(rules) {
+	if (!rules || typeof rules !== "object" || Array.isArray(rules)) return [];
+	const obj = rules;
+	const result = [];
+	for (const [key, val] of Object.entries(obj)) {
+		if (val === false || val === void 0 || val === null) continue;
+		if (val === true) result.push({ type: key });
+		else result.push({
+			type: key,
+			arg: val
+		});
+	}
+	return result;
+}
 
 //#endregion
 //#region ../../node_modules/.pnpm/@openuidev+react-lang@0.2.8_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__react@19.2.8_zod@4.4.3/node_modules/@openuidev/react-lang/dist/index.mjs
@@ -3278,7 +3602,89 @@ function useOpenUI() {
 function useRenderNode() {
 	return useOpenUI().renderNode;
 }
+/**
+* Get the triggerAction function for firing structured action events.
+*
+* @example
+* ```tsx
+* const triggerAction = useTriggerAction();
+* <button onClick={() => triggerAction("Submit", "myForm")}>
+* ```
+*/
+function useTriggerAction() {
+	return useOpenUI().triggerAction;
+}
+/**
+* Whether the LLM is currently streaming content.
+*/
+function useIsStreaming() {
+	return useOpenUI().isStreaming;
+}
+/**
+* Whether any Query is currently fetching data.
+* Useful for showing skeleton/loading states in data-driven components.
+*/
+function useIsQueryLoading() {
+	return useOpenUI().isQueryLoading;
+}
+/**
+* Get a form field value from the form state context.
+*
+* @example
+* ```tsx
+* const getFieldValue = useGetFieldValue();
+* const name = getFieldValue("contactForm", "name");
+* ```
+*/
+function useGetFieldValue() {
+	return useOpenUI().getFieldValue;
+}
+/**
+* Get the setFieldValue function for updating form field values.
+*
+* @example
+* ```tsx
+* const setFieldValue = useSetFieldValue();
+* <input onChange={(e) => setFieldValue("contactForm", "Input", "name", e.target.value, false)} />
+* ```
+*/
+function useSetFieldValue() {
+	return useOpenUI().setFieldValue;
+}
 const FormNameContext = createContext(void 0);
+/**
+* Get the current form name (set by the nearest parent Form component).
+* Returns undefined if not inside a Form.
+*/
+function useFormName() {
+	return useContext(FormNameContext);
+}
+/**
+* Persists a component's default/initial value into form state once streaming
+* finishes — but only if the user hasn't already set a value.
+*
+* Call this inside any form component that has a `defaultValue` or
+* `defaultChecked` prop. It is a no-op during streaming so that LLM
+* prop changes don't fight with partial state.
+*
+* @param shouldTriggerSaveCallback — defaults to `false` (only local state, no message persistence)
+*/
+function useSetDefaultValue({ formName, componentType, name, existingValue, defaultValue, shouldTriggerSaveCallback = false }) {
+	const setFieldValue = useSetFieldValue();
+	const isStreaming = useIsStreaming();
+	useEffect(() => {
+		if (!isStreaming && existingValue === void 0 && defaultValue !== void 0) setFieldValue(formName, componentType, name, defaultValue, shouldTriggerSaveCallback);
+	}, [
+		defaultValue,
+		existingValue,
+		formName,
+		componentType,
+		name,
+		isStreaming,
+		setFieldValue,
+		shouldTriggerSaveCallback
+	]);
+}
 /** Unwrap { value, componentType } wrapper from form field entries. Returns raw value. */
 function unwrapFieldValue(v) {
 	if (v && typeof v === "object" && !Array.isArray(v) && "value" in v) return v.value;
@@ -3758,29 +4164,91 @@ function Renderer({ response, library, isStreaming = false, onAction, onStateUpd
 		})
 	});
 }
-const FormValidationContext = createContext(null);
-
-//#endregion
-//#region ../ui-react/dist/openUiLibrary-BKXW7Iwx.js
-const propsFor = (props, container) => container ? props.extend({ children: z.array(z.any()).optional() }) : props;
 /**
-* catalog 的 OpenUI 投影：`defineComponent` 复用同一份 zod schema 与描述，
-* 渲染实现取自共享的 ui-kit 组件表，因此 OpenUI 档渲染的是我们的设计系统而不是 OpenUI 默认组件。
+* Mark a schema prop as reactive so runtime evaluation can preserve $bindings.
+*
+* The widened return type carries the eventual value shape into helpers like
+* `useStateField()`. The actual bound value is still resolved at render time.
 */
-const webskillOpenUiLibrary = createLibrary({
-	id: "webskill-shadcn",
-	components: uiCatalog.components.map((def) => defineComponent({
-		name: def.name,
-		description: def.description,
-		props: propsFor(def.props, def.children !== void 0),
-		component: ((input) => /* @__PURE__ */ jsx(CatalogNode, {
-			name: def.name,
-			props: input.props,
-			children: input.renderNode(input.props["children"])
-		}))
-	}))
-});
-const OPEN_UI_COMPONENTS = Object.keys(webskillOpenUiLibrary.components);
+function reactive(schema) {
+	markReactive(schema);
+	return schema;
+}
+function useStateField(name, value) {
+	const ctx = useOpenUI();
+	const formName = useFormName();
+	return resolveStateField(name, value, ctx.store ?? null, ctx.evaluationContext ?? null, (fieldName) => ctx.getFieldValue(formName, fieldName), (fieldName, nextValue) => ctx.setFieldValue(formName, void 0, fieldName, nextValue));
+}
+const FormValidationContext = createContext(null);
+function useFormValidation() {
+	return useContext(FormValidationContext);
+}
+function useCreateFormValidation() {
+	const [errors, setErrors] = useState({});
+	const errorsRef = useRef(errors);
+	errorsRef.current = errors;
+	const fieldsRef = useRef({});
+	const getFieldError = useCallback((name) => errorsRef.current[name], []);
+	const validateField = useCallback((name, value, rules) => {
+		const error = validate(value, rules);
+		setErrors((prev) => {
+			if (prev[name] === error) return prev;
+			return {
+				...prev,
+				[name]: error
+			};
+		});
+		return !error;
+	}, []);
+	const registerField = useCallback((name, rules, getValue) => {
+		fieldsRef.current[name] = {
+			rules,
+			getValue
+		};
+	}, []);
+	const unregisterField = useCallback((name) => {
+		delete fieldsRef.current[name];
+	}, []);
+	const validateForm = useCallback(() => {
+		let allValid = true;
+		const newErrors = {};
+		for (const [name, reg] of Object.entries(fieldsRef.current)) {
+			let value = reg.getValue();
+			if (value != null && typeof value === "object" && "value" in value && "componentType" in value) value = value.value;
+			const error = validate(value, reg.rules);
+			newErrors[name] = error;
+			if (error) allValid = false;
+		}
+		setErrors(newErrors);
+		return allValid;
+	}, []);
+	const clearFieldError = useCallback((name) => {
+		setErrors((prev) => {
+			if (prev[name] === void 0) return prev;
+			return {
+				...prev,
+				[name]: void 0
+			};
+		});
+	}, []);
+	return useMemo(() => ({
+		errors,
+		getFieldError,
+		validateField,
+		registerField,
+		unregisterField,
+		validateForm,
+		clearFieldError
+	}), [
+		errors,
+		getFieldError,
+		validateField,
+		registerField,
+		unregisterField,
+		validateForm,
+		clearFieldError
+	]);
+}
 
 //#endregion
-export { OPEN_UI_COMPONENTS, Renderer, webskillOpenUiLibrary };
+export { ACTION_STEPS, BuiltinActionType, FormNameContext, FormValidationContext, Renderer, ToolNotFoundError, builtInValidators, createLibrary, createParser, createStreamingParser, defineComponent, extractToolResult, generatePrompt, isReactiveAssign, mergeStatements, parseRules, parseStructuredRules, reactive, tagSchemaId, useCreateFormValidation, useFormName, useFormValidation, useGetFieldValue, useIsQueryLoading, useIsStreaming, useRenderNode, useSetDefaultValue, useSetFieldValue, useStateField, useTriggerAction, validate };

package/dist/{echarts-De78wXqV.js → echarts-BE7oV_Dl.js}

@@ -1,4 +1,4 @@
-import { r as __exportAll } from "./rolldown-runtime-BOF7iYI8.js";
+import { r as __exportAll } from "./rolldown-runtime-BHkdefai.js";
 
 //#region ../../node_modules/.pnpm/tslib@2.3.0/node_modules/tslib/tslib.es6.js
 /*! *****************************************************************************

package/dist/{env-8cY40DXB-CGnEVZby.js → env-Bj1MI2Ww.js}

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 
-//#region ../node/dist/env-8cY40DXB.js
+//#region ../node/src/env.ts
 /** 解析 .env（简单 KEY=VALUE 行解析，不引依赖）；文件缺失返回 undefined */
 function readEnvVars(dotenvPath) {
 	let raw;

package/dist/errors-BDZNpC13.js

@@ -0,0 +1,22 @@
+//#region ../core/src/errors.ts
+/**
+* 所有公开 API 抛出的结构化错误，code 供上层可编程处理
+* @stable
+*/
+var WebSkillError = class extends Error {
+	code;
+	details;
+	constructor(code, message, details) {
+		super(message);
+		this.name = "WebSkillError";
+		this.code = code;
+		this.details = details;
+	}
+};
+/** unknown 异常取消息文本（全仓单一来源，勿再本地重复定义） */
+function messageOf(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+
+//#endregion
+export { messageOf as n, WebSkillError as t };

package/dist/{eventTypes-FllCrX-Z-DNDeHWoG.js → eventTypes-Y07N8IAC.js}

@@ -1,4 +1,4 @@
-//#region ../governance/dist/eventTypes-FllCrX-Z.js
+//#region ../governance/src/audit/eventTypes.ts
 /**
 * 审计事件类型常量（FR-13.4）。
 *
@@ -38,12 +38,24 @@ const AUDIT_EVENT_TYPES = {
 	candidateSubmitted: "candidate.submitted",
 	candidateApproved: "candidate.approved",
 	candidateRejected: "candidate.rejected",
+	/** 候选记录被从审批队列里删除（仅 draft / pending-review / rejected 可删） */
+	candidateRemoved: "candidate.removed",
 	pagePerceived: "page.perceived",
 	pageAction: "page.action",
+	/**
+	* 一次页面操作引发了下载，但 `sandbox.downloadedFiles` 关着，模型因此一无所知
+	* （0.15.0 分册 15 · FR-15.7）。载荷只有计数与原因，不含文件名 / 大小 / 类型。
+	*/
+	pageDownloadUnreported: "page.download.unreported",
 	documentRead: "document.read",
 	documentSurfaceOpen: "document.surface.open",
 	/** 脚本按宿主声明的数据源取数（分册 16）；被拒也记，否则反复试探看不见 */
-	dataFetched: "data.fetch"
+	dataFetched: "data.fetch",
+	/**
+	* 技能脚本读用户本轮上传的文件（0.15.0 分册 17 · FR-17.7）。
+	* 载荷记文件名 / 类型 / 字节数与是否被拒，**不含文件内容**。
+	*/
+	uploadFileRead: "upload.file.read"
 };
 /** 稳定展示序：筛选下拉与文档表格都从这里取，不各自维护一份顺序 */
 const AUDIT_EVENT_TYPE_LIST = Object.values(AUDIT_EVENT_TYPES);