@world-engines/blocks-editor 0.1.0

package/LICENSE

@@ -0,0 +1,46 @@
+WorldEngine 官方作者工具许可证
+
+版权所有 (c) 2026 Nixdorfer。保留所有权利。
+
+本仓库的源代码、构建材料及附带资源（统称“本作品”）不是开源软件，
+不适用任何 OSI 认证的开源许可证。
+
+一、官方作者工具分发许可
+
+版权所有者可以通过其官方网站、npm registry、签名安装包或其他官方渠道，
+复制并分发由本作品构建的 WorldEngine 作者工具及其必要运行资源
+（统称“官方作者工具”）。仅版权所有者或其书面指定的发布者享有此分发权。
+
+二、作者用户许可
+
+从官方渠道取得官方作者工具的作者用户，可以：
+
+1. 安装和运行官方作者工具；
+2. 使用官方作者工具创作、编辑、预览、导入、导出和提交其有权处理的内容；
+3. 为上述使用目的制作合理必要的本地备份副本。
+
+三、未授予的权利
+
+除第二条明确允许的行为外，本许可证不授予作者用户或其他第三方以下权利：
+
+1. 修改、改编、反编译、反汇编或制作官方作者工具的派生作品；
+2. 复制、镜像、转发、再上传、出售、出租、再分发或再许可官方作者工具；
+3. 使用本作品的源代码、构建材料或任何部分开发、提供或训练其他产品或服务；
+4. 删除或规避版权、许可、签名、访问控制或其他权利管理信息。
+
+法律强制允许且合同不得排除的权利不受上述限制影响。
+
+四、源代码查看
+
+第三方可以在已获合法访问权限的范围内查看本作品，用于审查、安全研究或学习参考；
+查看不授予运行、复制、修改、分发、再许可或用于其他产品与服务的权利。
+
+五、无担保与责任限制
+
+本作品与官方作者工具均按“现状”提供，不附带任何明示或暗示的担保。
+在适用法律允许的最大范围内，版权所有者不对因访问或使用本作品或官方作者工具
+造成的任何损失承担责任。
+
+六、终止
+
+违反本许可证将立即终止相应的访问与使用权；终止不影响版权所有者已经产生的权利和救济。

package/README.md

@@ -0,0 +1,40 @@
+# @world-engines/blocks-editor
+
+Scratch 风格积木编辑器共享包 用户铁律 平台中所有"类代码"输入面统一用积木拼装 底层 ts/js。
+
+本包基于 Blockly 13 + zelos renderer + react-blockly 提供通用积木运行时
+首位消费者是 creator-editor 的 TriggerEditor 后续 advanced-mode 视图脚本 LLM 路由 经济触发 审核红线 任务条件 等"类代码"面陆续接入 不再各自造轮。
+
+## 导出契约
+
+`src/index.ts` 为 barrel export 后续按 T2-T7 任务依次填充
+
+- `BlocksWorkspace` React 组件 props {schema value onChange expertMode ctx}
+- `triggerAdapter` TriggerTree 适配器 toAst/fromAst/registerBlocks/toolbox
+- `liquidGlassDarkTheme` Blockly Theme 项目深色液态玻璃皮
+- `toTsExpression` / `fromTsExpression` Monaco 专家模式互转
+- `upgradeLegacyTrigger` / `upgradeScenarioTriggers` / `SCHEMA_VERSION` v1 → v2 升级器
+- `Adapter` interface 后续 ast 适配器范式
+
+## 8 个块名 触发器特化 见 ADR-0104 决策 5 6 7 8
+
+| 块 ID | 形状 | 颜色族 |
+| :--- | :--- | :--- |
+| `trigger_root` | cap 顶层容器 | 深青 |
+| `op_and` | C 形多 child | 橙 |
+| `op_or` | C 形多 child | 橙 |
+| `op_not` | cap 单 child | 橙 |
+| `leaf_time` | stack | 紫 |
+| `leaf_event` | stack | 绿 |
+| `leaf_nl` | stack | 绿 |
+| `leaf_attr_ref` | stack | 蓝 |
+
+## 与 ADR / PLAN 的关系
+
+- ADR-0104 `docs/adr/0104-scratch-block-editor-trigger-ui.md` 决策依据
+- PLAN `.scratch/editor-workbench-overhaul/scratch-block-trigger-ui.md` 实施清单
+- ADR-0096 引擎不动 本包仅做 UI 层与持久化升级
+
+## media 资源
+
+`public/blockly-media/` 自托管 Blockly 内置 svg + sound 离线 隐私 CSP 四角度禁止走 google CDN 见 ADR-0104 决策 11。

package/dist/adapters/trigger.d.ts

@@ -0,0 +1,72 @@
+export interface BlockNodeInputSlot {
+    readonly block?: BlockNode;
+}
+export interface BlockNodeNextSlot {
+    readonly block?: BlockNode;
+}
+export interface BlockNode {
+    readonly type: string;
+    readonly id?: string;
+    readonly x?: number;
+    readonly y?: number;
+    readonly fields?: {
+        readonly [name: string]: unknown;
+    };
+    readonly inputs?: {
+        readonly [name: string]: BlockNodeInputSlot;
+    };
+    readonly next?: BlockNodeNextSlot;
+    readonly extraState?: {
+        readonly [key: string]: unknown;
+    };
+}
+export interface BlocklyWorkspaceJson {
+    readonly blocks?: {
+        readonly languageVersion?: number;
+        readonly blocks?: ReadonlyArray<BlockNode>;
+    };
+}
+import type { SelectorAstV3, TriggerConditionNodeV3 } from "@world-engines/tmw";
+export type BlocksConditionExpressionV3 = {
+    readonly op: "literal";
+    readonly value: boolean;
+} | {
+    readonly op: "event_field";
+    readonly path: readonly string[];
+    readonly comparison: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "contains";
+    readonly value: string | number | boolean | null;
+} | {
+    readonly op: "selector_exists";
+    readonly selector: SelectorAstV3;
+} | {
+    readonly op: "nl_condition";
+    readonly stable_id: string;
+    readonly text: string;
+    readonly locale: string;
+    readonly anchor?: SelectorAstV3;
+} | {
+    readonly op: "not";
+    readonly value: BlocksConditionExpressionV3;
+} | {
+    readonly op: "all" | "any";
+    readonly values: readonly BlocksConditionExpressionV3[];
+};
+export type BlocksTriggerConditionNodeV3 = Omit<TriggerConditionNodeV3, "expression"> & {
+    readonly expression: BlocksConditionExpressionV3;
+};
+export declare const TMW_CONDITION_BLOCK_TYPES: Readonly<{
+    readonly root: "tmw_v3_condition_root";
+    readonly all: "tmw_v3_condition_all";
+    readonly any: "tmw_v3_condition_any";
+    readonly not: "tmw_v3_condition_not";
+    readonly literal: "tmw_v3_condition_literal";
+    readonly eventField: "tmw_v3_condition_event_field";
+    readonly selectorExists: "tmw_v3_condition_selector_exists";
+    readonly naturalLanguage: "tmw_v3_condition_natural_language";
+}>;
+/** 将一个现行 TMW3 condition node 投影为 Blockly JSON；不创建第二份运行时 authority。 */
+export declare const tmwConditionNodeToWorkspace: (condition: BlocksTriggerConditionNodeV3) => BlocklyWorkspaceJson;
+/** 从 Blockly 草稿严格重建同一个 TMW3 condition node。 */
+export declare const tmwConditionNodeFromWorkspace: (value: unknown) => BlocksTriggerConditionNodeV3;
+/** Fresh-only workspace parser；不迁移、不归一化旧 block。 */
+export declare const parseTmwWorkspaceV3: (value: unknown) => BlocklyWorkspaceJson;

package/dist/adapters/trigger.js

@@ -0,0 +1,206 @@
+export const TMW_CONDITION_BLOCK_TYPES = Object.freeze({
+    root: "tmw_v3_condition_root",
+    all: "tmw_v3_condition_all",
+    any: "tmw_v3_condition_any",
+    not: "tmw_v3_condition_not",
+    literal: "tmw_v3_condition_literal",
+    eventField: "tmw_v3_condition_event_field",
+    selectorExists: "tmw_v3_condition_selector_exists",
+    naturalLanguage: "tmw_v3_condition_natural_language",
+});
+const primitive = (value) => {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    throw new Error("tmw_condition_primitive_invalid");
+};
+const expressionToBlock = (expression) => {
+    switch (expression.op) {
+        case "literal": return { type: TMW_CONDITION_BLOCK_TYPES.literal, fields: { VALUE: expression.value ? "TRUE" : "FALSE" } };
+        case "event_field": return {
+            type: TMW_CONDITION_BLOCK_TYPES.eventField,
+            fields: {
+                PATH: expression.path.join("."),
+                COMPARISON: expression.comparison,
+                VALUE_JSON: JSON.stringify(expression.value),
+            },
+        };
+        case "selector_exists": {
+            return { type: TMW_CONDITION_BLOCK_TYPES.selectorExists, fields: { SELECTOR_JSON: JSON.stringify(expression.selector) } };
+        }
+        case "nl_condition": return {
+            type: TMW_CONDITION_BLOCK_TYPES.naturalLanguage,
+            fields: {
+                STABLE_ID: expression.stable_id,
+                TEXT: expression.text,
+                LOCALE: expression.locale,
+                ANCHOR_JSON: expression.anchor === undefined ? "" : JSON.stringify(expression.anchor),
+            },
+        };
+        case "not": return { type: TMW_CONDITION_BLOCK_TYPES.not, inputs: { VALUE: { block: expressionToBlock(expression.value) } } };
+        case "all":
+        case "any": return {
+            type: expression.op === "all" ? TMW_CONDITION_BLOCK_TYPES.all : TMW_CONDITION_BLOCK_TYPES.any,
+            extraState: { itemCount: expression.values.length },
+            inputs: Object.fromEntries(expression.values.map((value, index) => [`ITEM${index}`, { block: expressionToBlock(value) }])),
+        };
+    }
+};
+const fieldString = (node, name) => {
+    const value = node.fields?.[name];
+    if (typeof value !== "string")
+        throw new Error(`tmw_condition_field_required:${name}`);
+    return value;
+};
+const inputBlock = (node, name) => {
+    const value = node.inputs?.[name]?.block;
+    if (value === undefined)
+        throw new Error(`tmw_condition_input_required:${name}`);
+    return value;
+};
+const blockToExpression = (node, depth = 0) => {
+    if (depth > 32)
+        throw new Error("tmw_condition_depth_exceeded");
+    switch (node.type) {
+        case TMW_CONDITION_BLOCK_TYPES.literal:
+            return { op: "literal", value: fieldString(node, "VALUE") === "TRUE" };
+        case TMW_CONDITION_BLOCK_TYPES.eventField: {
+            const path = fieldString(node, "PATH").split(".").map((part) => part.trim()).filter(Boolean);
+            if (path.length === 0)
+                throw new Error("tmw_condition_event_path_required");
+            const comparison = fieldString(node, "COMPARISON");
+            if (!["eq", "neq", "gt", "gte", "lt", "lte", "contains"].includes(comparison))
+                throw new Error("tmw_condition_comparison_invalid");
+            return {
+                op: "event_field",
+                path,
+                comparison: comparison,
+                value: primitive(JSON.parse(fieldString(node, "VALUE_JSON"))),
+            };
+        }
+        case TMW_CONDITION_BLOCK_TYPES.selectorExists:
+            return { op: "selector_exists", selector: JSON.parse(fieldString(node, "SELECTOR_JSON")) };
+        case TMW_CONDITION_BLOCK_TYPES.naturalLanguage: {
+            const anchorJson = fieldString(node, "ANCHOR_JSON").trim();
+            return {
+                op: "nl_condition",
+                stable_id: fieldString(node, "STABLE_ID"),
+                text: fieldString(node, "TEXT"),
+                locale: fieldString(node, "LOCALE"),
+                ...(anchorJson.length === 0 ? {} : { anchor: JSON.parse(anchorJson) }),
+            };
+        }
+        case TMW_CONDITION_BLOCK_TYPES.not:
+            return { op: "not", value: blockToExpression(inputBlock(node, "VALUE"), depth + 1) };
+        case TMW_CONDITION_BLOCK_TYPES.all:
+        case TMW_CONDITION_BLOCK_TYPES.any: {
+            const rawCount = node.extraState?.itemCount;
+            if (!Number.isSafeInteger(rawCount) || rawCount < 1 || rawCount > 16)
+                throw new Error("tmw_condition_item_count_invalid");
+            const values = Array.from({ length: rawCount }, (_, index) => blockToExpression(inputBlock(node, `ITEM${index}`), depth + 1));
+            return { op: node.type === TMW_CONDITION_BLOCK_TYPES.all ? "all" : "any", values };
+        }
+        default: throw new Error(`tmw_condition_block_unsupported:${node.type}`);
+    }
+};
+/** 将一个现行 TMW3 condition node 投影为 Blockly JSON；不创建第二份运行时 authority。 */
+export const tmwConditionNodeToWorkspace = (condition) => ({
+    blocks: {
+        languageVersion: 0,
+        blocks: [{
+                type: TMW_CONDITION_BLOCK_TYPES.root,
+                id: condition.stable_id,
+                x: 32,
+                y: 32,
+                fields: {
+                    STABLE_ID: condition.stable_id,
+                    DOMAIN: condition.effective_time.domain,
+                    DUE_VALUE: condition.effective_time.due_value,
+                    EFFECTIVE_VALUE: condition.effective_time.effective_value,
+                    CROSSING_POLICY: condition.effective_time.crossing_policy,
+                    REAL_TIME_CLOCK: condition.effective_time.real_time_clock ?? "active_play",
+                    WALL_CLOCK_POLICY: condition.effective_time.wall_clock_policy ?? "active_session_only",
+                },
+                inputs: { EXPRESSION: { block: expressionToBlock(condition.expression) } },
+            }],
+    },
+});
+/** 从 Blockly 草稿严格重建同一个 TMW3 condition node。 */
+export const tmwConditionNodeFromWorkspace = (value) => {
+    const workspace = parseTmwWorkspaceV3(value);
+    const roots = workspace.blocks?.blocks?.filter((block) => block.type === TMW_CONDITION_BLOCK_TYPES.root) ?? [];
+    if (roots.length !== 1)
+        throw new Error(`tmw_condition_root_count_invalid:${roots.length}`);
+    const root = roots[0];
+    const domain = fieldString(root, "DOMAIN");
+    if (!["logical_seq", "world_time", "presentation_seq", "real_time"].includes(domain))
+        throw new Error("tmw_condition_domain_invalid");
+    const numberField = (name) => {
+        const value = root.fields?.[name];
+        const parsed = typeof value === "number" ? value : Number(value);
+        if (!Number.isFinite(parsed))
+            throw new Error(`tmw_condition_number_invalid:${name}`);
+        return parsed;
+    };
+    const realTime = domain === "real_time";
+    return {
+        kind: "condition",
+        stable_id: fieldString(root, "STABLE_ID"),
+        effective_time: {
+            domain: domain,
+            due_value: numberField("DUE_VALUE"),
+            effective_value: numberField("EFFECTIVE_VALUE"),
+            crossing_policy: fieldString(root, "CROSSING_POLICY"),
+            real_time_clock: realTime ? fieldString(root, "REAL_TIME_CLOCK") : null,
+            wall_clock_policy: realTime ? fieldString(root, "WALL_CLOCK_POLICY") : null,
+        },
+        expression: blockToExpression(inputBlock(root, "EXPRESSION")),
+    };
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseNode = (value, active) => {
+    if (!isRecord(value) || typeof value.type !== "string" || value.type.length === 0) {
+        throw new Error("tmw_workspace_node_invalid");
+    }
+    if (active.has(value))
+        throw new Error("tmw_workspace_cycle_invalid");
+    active.add(value);
+    if (value.inputs !== undefined) {
+        if (!isRecord(value.inputs))
+            throw new Error("tmw_workspace_inputs_invalid");
+        for (const slot of Object.values(value.inputs)) {
+            if (!isRecord(slot))
+                throw new Error("tmw_workspace_input_slot_invalid");
+            if (slot.block !== undefined)
+                parseNode(slot.block, active);
+        }
+    }
+    if (value.next !== undefined) {
+        if (!isRecord(value.next))
+            throw new Error("tmw_workspace_next_invalid");
+        if (value.next.block !== undefined)
+            parseNode(value.next.block, active);
+    }
+    active.delete(value);
+    return value;
+};
+/** Fresh-only workspace parser；不迁移、不归一化旧 block。 */
+export const parseTmwWorkspaceV3 = (value) => {
+    if (!isRecord(value))
+        throw new Error("tmw_workspace_invalid");
+    if (value.blocks === undefined)
+        return value;
+    if (!isRecord(value.blocks))
+        throw new Error("tmw_workspace_blocks_invalid");
+    if (value.blocks.languageVersion !== undefined
+        && (!Number.isSafeInteger(value.blocks.languageVersion) || value.blocks.languageVersion !== 0)) {
+        throw new Error("tmw_workspace_language_version_invalid");
+    }
+    if (value.blocks.blocks !== undefined) {
+        if (!Array.isArray(value.blocks.blocks))
+            throw new Error("tmw_workspace_roots_invalid");
+        value.blocks.blocks.forEach((node) => parseNode(node, new Set()));
+    }
+    return value;
+};

package/dist/blockly-config.d.ts

@@ -0,0 +1,3 @@
+export declare const DRAG_SNAP_RADIUS = 40;
+export declare const DRAG_CONNECT_SNAP_RADIUS = 40;
+export declare function applyDragTolerance(): void;

package/dist/blockly-config.js

@@ -0,0 +1,7 @@
+import { config as blocklyConfig } from "blockly";
+export const DRAG_SNAP_RADIUS = 40;
+export const DRAG_CONNECT_SNAP_RADIUS = 40;
+export function applyDragTolerance() {
+    blocklyConfig.snapRadius = DRAG_SNAP_RADIUS;
+    blocklyConfig.connectingSnapRadius = DRAG_CONNECT_SNAP_RADIUS;
+}

package/dist/blocks/ctx.d.ts

@@ -0,0 +1,67 @@
+import type * as Blockly from "blockly";
+import type { WorldTimeBounds } from "./time-fields.js";
+import type { SdkCatalog } from "../sdk-to-block/signature.js";
+import type { ViewBlockCatalog } from "../view-to-block/index.js";
+export interface CtxEvent {
+    readonly id: string;
+    readonly name: string;
+}
+export interface CtxEntityAttr {
+    readonly key: string;
+    readonly label: string;
+}
+export interface CtxEntity {
+    readonly id: string;
+    readonly name: string;
+    readonly attrs: ReadonlyArray<CtxEntityAttr>;
+    readonly states?: ReadonlyArray<CtxEntityState>;
+}
+export interface CtxEntityState {
+    readonly key: string;
+    readonly label: string;
+}
+export interface CtxEdge {
+    readonly id: string;
+    readonly src_id: string;
+    readonly dst_id: string;
+    readonly kind: string;
+    readonly label: string;
+}
+export interface CtxVariable {
+    readonly name: string;
+    readonly type: "string" | "number" | "boolean";
+}
+export interface BlocksEditorCtx {
+    readonly event_list: ReadonlyArray<CtxEvent>;
+    readonly entity_list: ReadonlyArray<CtxEntity>;
+    readonly edge_list?: ReadonlyArray<CtxEdge>;
+    readonly variable_list?: ReadonlyArray<CtxVariable>;
+    readonly sdk_catalog?: SdkCatalog;
+    readonly view_catalog?: ViewBlockCatalog;
+    readonly worldTime?: WorldTimeBounds;
+}
+export declare const EMPTY_CTX: BlocksEditorCtx;
+export declare const BlocksEditorCtxContext: import("react").Context<BlocksEditorCtx>;
+export declare function useBlocksEditorCtx(): BlocksEditorCtx;
+export declare const WORKSPACE_CTX_PROPERTY: "__blocksEditorCtx__";
+export interface WorkspaceWithCtx {
+    [WORKSPACE_CTX_PROPERTY]?: BlocksEditorCtx;
+}
+export declare function attachCtxToWorkspace(workspace: Blockly.WorkspaceSvg, ctx: BlocksEditorCtx): void;
+export declare function readCtxFromWorkspace(workspace: Blockly.Workspace | null | undefined): BlocksEditorCtx;
+export declare const PLACEHOLDER_EVENT_OPTION: readonly [string, string];
+export declare const PLACEHOLDER_ENTITY_OPTION: readonly [string, string];
+export declare const PLACEHOLDER_ATTR_OPTION: readonly [string, string];
+export declare const PLACEHOLDER_EDGE_OPTION: readonly [string, string];
+export declare const PLACEHOLDER_VARIABLE_OPTION: readonly [string, string];
+export declare const PLACEHOLDER_STATE_OPTION: readonly [string, string];
+export declare function eventOptions(ctx: BlocksEditorCtx): ReadonlyArray<readonly [string, string]>;
+export declare function entityOptions(ctx: BlocksEditorCtx): ReadonlyArray<readonly [string, string]>;
+export declare function attrOptionsForEntity(ctx: BlocksEditorCtx, entityId: string): ReadonlyArray<readonly [string, string]>;
+export declare function edgeOptions(ctx: BlocksEditorCtx): ReadonlyArray<readonly [string, string]>;
+export declare function variableOptions(ctx: BlocksEditorCtx): ReadonlyArray<readonly [string, string]>;
+export declare function stateOptionsForEntity(ctx: BlocksEditorCtx, entityId: string): ReadonlyArray<readonly [string, string]>;
+export declare function findEntityName(ctx: BlocksEditorCtx, entityId: string): string;
+export declare function findAttrLabel(ctx: BlocksEditorCtx, entityId: string, attrKey: string): string;
+export declare function findEdgeLabel(ctx: BlocksEditorCtx, edgeId: string): string;
+export declare function findStateLabel(ctx: BlocksEditorCtx, entityId: string, stateKey: string): string;

package/dist/blocks/ctx.js

@@ -0,0 +1,96 @@
+import { createContext, useContext } from "react";
+export const EMPTY_CTX = {
+    event_list: [],
+    entity_list: []
+};
+export const BlocksEditorCtxContext = createContext(EMPTY_CTX);
+export function useBlocksEditorCtx() {
+    return useContext(BlocksEditorCtxContext);
+}
+export const WORKSPACE_CTX_PROPERTY = "__blocksEditorCtx__";
+export function attachCtxToWorkspace(workspace, ctx) {
+    workspace[WORKSPACE_CTX_PROPERTY] = ctx;
+}
+export function readCtxFromWorkspace(workspace) {
+    if (!workspace)
+        return EMPTY_CTX;
+    const carrier = workspace;
+    return carrier[WORKSPACE_CTX_PROPERTY] ?? EMPTY_CTX;
+}
+export const PLACEHOLDER_EVENT_OPTION = [
+    "(no events declared)",
+    "__none__"
+];
+export const PLACEHOLDER_ENTITY_OPTION = [
+    "(no entities declared)",
+    "__none__"
+];
+export const PLACEHOLDER_ATTR_OPTION = [
+    "(no attrs)",
+    "__none__"
+];
+export const PLACEHOLDER_EDGE_OPTION = [
+    "(no edges declared)",
+    "__none__"
+];
+export const PLACEHOLDER_VARIABLE_OPTION = [
+    "(no variables)",
+    "__none__"
+];
+export const PLACEHOLDER_STATE_OPTION = [
+    "(no states)",
+    "__none__"
+];
+export function eventOptions(ctx) {
+    if (ctx.event_list.length === 0)
+        return [PLACEHOLDER_EVENT_OPTION];
+    return ctx.event_list.map((e) => [e.name, e.id]);
+}
+export function entityOptions(ctx) {
+    if (ctx.entity_list.length === 0)
+        return [PLACEHOLDER_ENTITY_OPTION];
+    return ctx.entity_list.map((e) => [e.name, e.id]);
+}
+export function attrOptionsForEntity(ctx, entityId) {
+    const entity = ctx.entity_list.find((e) => e.id === entityId);
+    if (!entity || entity.attrs.length === 0)
+        return [PLACEHOLDER_ATTR_OPTION];
+    return entity.attrs.map((a) => [a.label, a.key]);
+}
+export function edgeOptions(ctx) {
+    const edges = ctx.edge_list ?? [];
+    if (edges.length === 0)
+        return [PLACEHOLDER_EDGE_OPTION];
+    return edges.map((e) => [e.label, e.id]);
+}
+export function variableOptions(ctx) {
+    const vars = ctx.variable_list ?? [];
+    if (vars.length === 0)
+        return [PLACEHOLDER_VARIABLE_OPTION];
+    return vars.map((v) => [v.name, v.name]);
+}
+export function stateOptionsForEntity(ctx, entityId) {
+    const entity = ctx.entity_list.find((e) => e.id === entityId);
+    const states = entity?.states ?? [];
+    if (states.length === 0)
+        return [PLACEHOLDER_STATE_OPTION];
+    return states.map((s) => [s.label, s.key]);
+}
+export function findEntityName(ctx, entityId) {
+    const entity = ctx.entity_list.find((e) => e.id === entityId);
+    return entity?.name ?? entityId;
+}
+export function findAttrLabel(ctx, entityId, attrKey) {
+    const entity = ctx.entity_list.find((e) => e.id === entityId);
+    const attr = entity?.attrs.find((a) => a.key === attrKey);
+    return attr?.label ?? attrKey;
+}
+export function findEdgeLabel(ctx, edgeId) {
+    const edge = (ctx.edge_list ?? []).find((e) => e.id === edgeId);
+    return edge?.label ?? edgeId;
+}
+export function findStateLabel(ctx, entityId, stateKey) {
+    const entity = ctx.entity_list.find((e) => e.id === entityId);
+    const state = (entity?.states ?? []).find((s) => s.key === stateKey);
+    return state?.label ?? stateKey;
+}

package/dist/blocks/registry-taxonomy.d.ts

@@ -0,0 +1,12 @@
+export declare const HAT_BLOCK_TYPES: readonly ["when_scenario_start", "when_value_changed", "when_time_changed", "when_entity_state_changed", "when_var_changed", "when_time_reached", "when_recall_success"];
+export type HatBlockType = (typeof HAT_BLOCK_TYPES)[number];
+export declare const HAT_TYPES: ReadonlySet<string>;
+export declare function isHatType(type: string): type is HatBlockType;
+export declare const CONTROL_STATEMENT_TYPES: readonly ["if", "if_else", "repeat", "repeat_until", "wait_seconds", "stop_this_script"];
+export declare const SENSING_REPORTER_TYPES: readonly ["sense_time_year", "sense_time_month", "sense_time_day", "sense_time_hour", "sense_time_minute", "sense_time_second", "sense_object_state", "sense_object_attr", "sense_edge_relation", "sense_relation_ref", "sense_object_frozen"];
+export declare const OPERATOR_BOOLEAN_TYPES: readonly ["op_and", "op_or", "op_not", "op_equals", "op_greater", "op_less", "op_contains", "op_time_crossed"];
+export declare const OPERATOR_NUMBER_TYPES: readonly ["op_add", "op_subtract", "op_multiply", "op_divide", "op_mod", "op_round", "op_abs"];
+export declare const OPERATOR_STRING_TYPES: readonly ["op_join", "op_letter_of", "op_length_of"];
+export declare const VARIABLE_TYPES: readonly ["var_read", "var_set", "var_change", "var_const_boolean", "var_const_value", "var_const_time"];
+export declare const ENTITY_OP_TYPES: readonly ["entity_freeze", "entity_toggle", "entity_enable", "entity_disable", "attr_set"];
+export declare const TIME_OP_TYPES: readonly ["time_advance", "time_set"];

package/dist/blocks/registry-taxonomy.js

@@ -0,0 +1,79 @@
+// 独立 taxonomy 描述所有新 block 的形状分类 (hat/statement/reporter/boolean)
+// 与 registry.ts 解耦 避免 generator/adapter 依赖 registry 造成循环
+export const HAT_BLOCK_TYPES = [
+    "when_scenario_start",
+    "when_value_changed",
+    "when_time_changed",
+    "when_entity_state_changed",
+    "when_var_changed",
+    "when_time_reached",
+    "when_recall_success"
+];
+export const HAT_TYPES = new Set(HAT_BLOCK_TYPES);
+export function isHatType(type) {
+    return HAT_TYPES.has(type);
+}
+export const CONTROL_STATEMENT_TYPES = [
+    "if",
+    "if_else",
+    "repeat",
+    "repeat_until",
+    "wait_seconds",
+    "stop_this_script"
+];
+export const SENSING_REPORTER_TYPES = [
+    "sense_time_year",
+    "sense_time_month",
+    "sense_time_day",
+    "sense_time_hour",
+    "sense_time_minute",
+    "sense_time_second",
+    "sense_object_state",
+    "sense_object_attr",
+    "sense_edge_relation",
+    "sense_relation_ref",
+    "sense_object_frozen"
+];
+export const OPERATOR_BOOLEAN_TYPES = [
+    "op_and",
+    "op_or",
+    "op_not",
+    "op_equals",
+    "op_greater",
+    "op_less",
+    "op_contains",
+    "op_time_crossed"
+];
+export const OPERATOR_NUMBER_TYPES = [
+    "op_add",
+    "op_subtract",
+    "op_multiply",
+    "op_divide",
+    "op_mod",
+    "op_round",
+    "op_abs"
+];
+export const OPERATOR_STRING_TYPES = [
+    "op_join",
+    "op_letter_of",
+    "op_length_of"
+];
+export const VARIABLE_TYPES = [
+    "var_read",
+    "var_set",
+    "var_change",
+    "var_const_boolean",
+    "var_const_value",
+    "var_const_time"
+];
+export const ENTITY_OP_TYPES = [
+    "entity_freeze",
+    "entity_toggle",
+    "entity_enable",
+    "entity_disable",
+    "attr_set"
+];
+export const TIME_OP_TYPES = [
+    "time_advance",
+    "time_set"
+];

package/dist/blocks/registry.d.ts

@@ -0,0 +1,39 @@
+export declare const BLOCK_TYPES: {
+    readonly triggerRoot: "trigger_def_root";
+    readonly opAnd: "trigger_def_and";
+    readonly opOr: "trigger_def_or";
+    readonly opNot: "trigger_def_not";
+    readonly leafTime: "trigger_def_time";
+    readonly leafEvent: "trigger_def_event";
+    readonly leafNl: "trigger_def_nl";
+    readonly leafAttrRef: "trigger_def_attr_ref";
+    readonly leafRelationRef: "trigger_def_relation_ref";
+    readonly leafDaySegment: "trigger_def_day_segment";
+};
+export type BlockTypeId = (typeof BLOCK_TYPES)[keyof typeof BLOCK_TYPES];
+export declare const FIELD_NAMES: {
+    readonly closeMode: "close_mode";
+    readonly eventId: "event_id";
+    readonly delayMs: "delay_ms";
+    readonly delaySeconds: "delay_seconds";
+    readonly text: "text";
+    readonly milestone: "milestone";
+    readonly entityId: "entity_id";
+    readonly attrKey: "attr_key";
+    readonly srcId: "src_id";
+    readonly dstId: "dst_id";
+    readonly kind: "kind";
+    readonly segment: "segment";
+    readonly expectedValue: "expected_value";
+};
+export declare const INPUT_NAMES: {
+    readonly tree: "tree";
+    readonly closeWhen: "close_when";
+    readonly children: "children";
+    readonly child: "child";
+};
+export declare const CLOSE_MODE_OPTIONS: ReadonlyArray<readonly [string, string]>;
+export declare function registerTriggerBlocks(): void;
+export declare function listTriggerBlockTypes(): ReadonlyArray<BlockTypeId>;
+export declare function isTriggerBlockRegistered(type: BlockTypeId): boolean;
+export { HAT_BLOCK_TYPES, HAT_TYPES, isHatType, CONTROL_STATEMENT_TYPES, SENSING_REPORTER_TYPES, OPERATOR_BOOLEAN_TYPES, OPERATOR_NUMBER_TYPES, OPERATOR_STRING_TYPES, VARIABLE_TYPES, ENTITY_OP_TYPES, TIME_OP_TYPES } from "./registry-taxonomy.js";