refactor: reorganize package structure and decouple framework packages (#338)

* refactor: reorganize package structure and decouple framework packages

## Package Structure Reorganization
- Reorganized 55 packages into categorized subdirectories:
  - packages/framework/ - Generic framework (Laya/Cocos compatible)
  - packages/engine/ - ESEngine core modules
  - packages/rendering/ - Rendering modules (WASM dependent)
  - packages/physics/ - Physics modules
  - packages/streaming/ - World streaming
  - packages/network-ext/ - Network extensions
  - packages/editor/ - Editor framework and plugins
  - packages/rust/ - Rust WASM engine
  - packages/tools/ - Build tools and SDK

## Framework Package Decoupling
- Decoupled behavior-tree and blueprint packages from ESEngine dependencies
- Created abstracted interfaces (IBTAssetManager, IBehaviorTreeAssetContent)
- ESEngine-specific code moved to esengine/ subpath exports
- Framework packages now usable with Cocos/Laya without ESEngine

## CI Configuration
- Updated CI to only type-check and lint framework packages
- Added type-check:framework and lint:framework scripts

## Breaking Changes
- Package import paths changed due to directory reorganization
- ESEngine integrations now use subpath imports (e.g., '@esengine/behavior-tree/esengine')

* fix: update es-engine file path after directory reorganization

* docs: update README to focus on framework over engine

* ci: only build framework packages, remove Rust/WASM dependencies

* fix: remove esengine subpath from behavior-tree and blueprint builds

ESEngine integration code will only be available in full engine builds.
Framework packages are now purely engine-agnostic.

* fix: move network-protocols to framework, build both in CI

* fix: update workflow paths from packages/core to packages/framework/core

* fix: exclude esengine folder from type-check in behavior-tree and blueprint

* fix: update network tsconfig references to new paths

* fix: add test:ci:framework to only test framework packages in CI

* fix: only build core and math npm packages in CI

* fix: exclude test files from CodeQL and fix string escaping security issue

packages/engine/platform-common/src/polyfills/TextDecoderPolyfill.ts

@@ -0,0 +1,235 @@
+/**
+ * TextDecoder polyfill
+ *
+ * 用于不原生支持 TextDecoder 的平台（如微信小游戏 iOS 环境）
+ *
+ * 支持以下编码格式：
+ * - UTF-8（包含1-4字节字符、代理对）
+ * - ASCII
+ * - UTF-16LE
+ */
+class TextDecoderPolyfill {
+    /**
+     * 编码格式
+     */
+    readonly encoding: string;
+
+    /**
+     * 是否在遇到无效序列时抛出错误
+     */
+    readonly fatal: boolean = false;
+
+    /**
+     * 是否忽略 BOM（字节顺序标记）
+     */
+    readonly ignoreBOM: boolean = false;
+
+    /**
+     * 创建 TextDecoder 实例
+     *
+     * @param encoding - 编码格式，默认 'utf-8'
+     * @param options - 解码选项
+     */
+    constructor(encoding: string = 'utf-8', options?: TextDecoderOptions) {
+        this.encoding = encoding.toLowerCase().replace('-', '');
+        if (options?.fatal) {
+            this.fatal = options.fatal;
+        }
+        if (options?.ignoreBOM) {
+            this.ignoreBOM = options.ignoreBOM;
+        }
+    }
+
+    /**
+     * 将二进制数据解码为字符串
+     *
+     * @param input - 要解码的二进制数据
+     * @param options - 解码选项
+     * @returns 解码后的字符串
+     */
+    decode(input?: BufferSource | null, options?: TextDecodeOptions): string {
+        if (!input) return '';
+
+        const bytes = input instanceof Uint8Array
+            ? input
+            : input instanceof ArrayBuffer
+                ? new Uint8Array(input)
+                : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+
+        if (this.encoding === 'utf8' || this.encoding === 'utf-8') {
+            return this.decodeUTF8(bytes);
+        }
+
+        if (this.encoding === 'ascii' || this.encoding === 'usascii') {
+            return this.decodeASCII(bytes);
+        }
+
+        if (this.encoding === 'utf16le' || this.encoding === 'utf-16le') {
+            return this.decodeUTF16LE(bytes);
+        }
+
+        // 降级：作为 ASCII 处理
+        return this.decodeASCII(bytes);
+    }
+
+    /**
+     * 解码 UTF-8 数据
+     *
+     * @param bytes - 字节数组
+     * @returns 解码后的字符串
+     */
+    private decodeUTF8(bytes: Uint8Array): string {
+        const result: string[] = [];
+        let i = 0;
+
+        // 跳过 BOM（如果存在且不忽略）
+        if (!this.ignoreBOM && bytes.length >= 3 &&
+            bytes[0] === 0xEF && bytes[1] === 0xBB && bytes[2] === 0xBF) {
+            i = 3;
+        }
+
+        while (i < bytes.length) {
+            const byte1 = bytes[i++];
+
+            if (byte1 < 0x80) {
+                // 1字节字符（ASCII: 0xxxxxxx）
+                result.push(String.fromCharCode(byte1));
+            } else if ((byte1 & 0xE0) === 0xC0) {
+                // 2字节字符（110xxxxx 10xxxxxx）
+                if (i >= bytes.length) {
+                    if (this.fatal) throw new TypeError('无效的 UTF-8 序列');
+                    result.push('\uFFFD');
+                    break;
+                }
+                const byte2 = bytes[i++];
+                if ((byte2 & 0xC0) !== 0x80) {
+                    if (this.fatal) throw new TypeError('无效的 UTF-8 序列');
+                    result.push('\uFFFD');
+                    i--;
+                    continue;
+                }
+                result.push(String.fromCharCode(
+                    ((byte1 & 0x1F) << 6) | (byte2 & 0x3F)
+                ));
+            } else if ((byte1 & 0xF0) === 0xE0) {
+                // 3字节字符（1110xxxx 10xxxxxx 10xxxxxx）
+                if (i + 1 >= bytes.length) {
+                    if (this.fatal) throw new TypeError('无效的 UTF-8 序列');
+                    result.push('\uFFFD');
+                    break;
+                }
+                const byte2 = bytes[i++];
+                const byte3 = bytes[i++];
+                if ((byte2 & 0xC0) !== 0x80 || (byte3 & 0xC0) !== 0x80) {
+                    if (this.fatal) throw new TypeError('无效的 UTF-8 序列');
+                    result.push('\uFFFD');
+                    i -= 2;
+                    continue;
+                }
+                result.push(String.fromCharCode(
+                    ((byte1 & 0x0F) << 12) | ((byte2 & 0x3F) << 6) | (byte3 & 0x3F)
+                ));
+            } else if ((byte1 & 0xF8) === 0xF0) {
+                // 4字节字符（11110xxx 10xxxxxx 10xxxxxx 10xxxxxx）
+                if (i + 2 >= bytes.length) {
+                    if (this.fatal) throw new TypeError('无效的 UTF-8 序列');
+                    result.push('\uFFFD');
+                    break;
+                }
+                const byte2 = bytes[i++];
+                const byte3 = bytes[i++];
+                const byte4 = bytes[i++];
+                if ((byte2 & 0xC0) !== 0x80 || (byte3 & 0xC0) !== 0x80 || (byte4 & 0xC0) !== 0x80) {
+                    if (this.fatal) throw new TypeError('无效的 UTF-8 序列');
+                    result.push('\uFFFD');
+                    i -= 3;
+                    continue;
+                }
+                // 计算码点并转换为代理对
+                const codePoint = ((byte1 & 0x07) << 18) | ((byte2 & 0x3F) << 12) |
+                    ((byte3 & 0x3F) << 6) | (byte4 & 0x3F);
+                if (codePoint > 0x10FFFF) {
+                    if (this.fatal) throw new TypeError('无效的 UTF-8 序列');
+                    result.push('\uFFFD');
+                    continue;
+                }
+                const surrogate = codePoint - 0x10000;
+                result.push(
+                    String.fromCharCode(0xD800 + (surrogate >> 10)),
+                    String.fromCharCode(0xDC00 + (surrogate & 0x3FF))
+                );
+            } else {
+                // 无效字节
+                if (this.fatal) throw new TypeError('无效的 UTF-8 序列');
+                result.push('\uFFFD');
+            }
+        }
+
+        return result.join('');
+    }
+
+    /**
+     * 解码 ASCII 数据
+     *
+     * @param bytes - 字节数组
+     * @returns 解码后的字符串
+     */
+    private decodeASCII(bytes: Uint8Array): string {
+        const result: string[] = [];
+        for (let i = 0; i < bytes.length; i++) {
+            result.push(String.fromCharCode(bytes[i] & 0x7F));
+        }
+        return result.join('');
+    }
+
+    /**
+     * 解码 UTF-16LE 数据
+     *
+     * @param bytes - 字节数组
+     * @returns 解码后的字符串
+     */
+    private decodeUTF16LE(bytes: Uint8Array): string {
+        const result: string[] = [];
+
+        // 跳过 BOM（如果存在）
+        let i = 0;
+        if (!this.ignoreBOM && bytes.length >= 2 &&
+            bytes[0] === 0xFF && bytes[1] === 0xFE) {
+            i = 2;
+        }
+
+        for (; i + 1 < bytes.length; i += 2) {
+            const codeUnit = bytes[i] | (bytes[i + 1] << 8);
+            result.push(String.fromCharCode(codeUnit));
+        }
+
+        return result.join('');
+    }
+}
+
+/**
+ * 安装 TextDecoder polyfill
+ *
+ * 如果当前环境不支持 TextDecoder，则安装 polyfill
+ *
+ * @returns 是否安装了 polyfill
+ */
+export function installTextDecoderPolyfill(): boolean {
+    if (typeof globalThis.TextDecoder === 'undefined') {
+        (globalThis as any).TextDecoder = TextDecoderPolyfill;
+        console.log('[Polyfill] TextDecoder 已安装');
+        return true;
+    }
+    return false;
+}
+
+/**
+ * 检查 TextDecoder 是否可用（原生或 polyfill）
+ *
+ * @returns 是否可用
+ */
+export function isTextDecoderAvailable(): boolean {
+    return typeof globalThis.TextDecoder !== 'undefined';
+}
+
+export { TextDecoderPolyfill };

packages/engine/platform-common/src/polyfills/TextEncoderPolyfill.ts

@@ -0,0 +1,167 @@
+/**
+ * TextEncoder polyfill
+ *
+ * 用于不原生支持 TextEncoder 的平台（如微信小游戏 iOS 环境）
+ *
+ * 支持 UTF-8 编码，包含：
+ * - ASCII 字符（1字节输出）
+ * - 扩展 Unicode（2-4字节输出）
+ * - BMP 外字符的代理对处理
+ */
+class TextEncoderPolyfill {
+    /**
+     * 编码格式（始终为 'utf-8'）
+     */
+    readonly encoding: string = 'utf-8';
+
+    /**
+     * 将字符串编码为 UTF-8 字节数组
+     *
+     * @param input - 要编码的字符串
+     * @returns UTF-8 编码的字节数组
+     */
+    encode(input: string = ''): Uint8Array {
+        const bytes: number[] = [];
+
+        for (let i = 0; i < input.length; i++) {
+            let codePoint = input.charCodeAt(i);
+
+            // 处理代理对（BMP 外的字符）
+            if (codePoint >= 0xD800 && codePoint <= 0xDBFF) {
+                // 高代理项
+                if (i + 1 < input.length) {
+                    const next = input.charCodeAt(i + 1);
+                    if (next >= 0xDC00 && next <= 0xDFFF) {
+                        // 低代理项 - 组合成完整码点
+                        codePoint = 0x10000 + ((codePoint - 0xD800) << 10) + (next - 0xDC00);
+                        i++; // 跳过低代理项
+                    }
+                }
+            } else if (codePoint >= 0xDC00 && codePoint <= 0xDFFF) {
+                // 孤立的低代理项 - 替换为替换字符
+                codePoint = 0xFFFD;
+            }
+
+            if (codePoint < 0x80) {
+                // 1字节字符（ASCII）
+                bytes.push(codePoint);
+            } else if (codePoint < 0x800) {
+                // 2字节字符
+                bytes.push(0xC0 | (codePoint >> 6));
+                bytes.push(0x80 | (codePoint & 0x3F));
+            } else if (codePoint < 0x10000) {
+                // 3字节字符
+                bytes.push(0xE0 | (codePoint >> 12));
+                bytes.push(0x80 | ((codePoint >> 6) & 0x3F));
+                bytes.push(0x80 | (codePoint & 0x3F));
+            } else if (codePoint <= 0x10FFFF) {
+                // 4字节字符
+                bytes.push(0xF0 | (codePoint >> 18));
+                bytes.push(0x80 | ((codePoint >> 12) & 0x3F));
+                bytes.push(0x80 | ((codePoint >> 6) & 0x3F));
+                bytes.push(0x80 | (codePoint & 0x3F));
+            } else {
+                // 无效码点 - 使用替换字符
+                bytes.push(0xEF, 0xBF, 0xBD); // U+FFFD 的 UTF-8 编码
+            }
+        }
+
+        return new Uint8Array(bytes);
+    }
+
+    /**
+     * 将字符串编码到目标缓冲区
+     *
+     * 尽可能多地将源字符串编码到目标缓冲区中
+     *
+     * @param source - 要编码的字符串
+     * @param destination - 目标缓冲区
+     * @returns 包含已读取字符数和已写入字节数的对象
+     */
+    encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult {
+        let read = 0;
+        let written = 0;
+
+        for (let i = 0; i < source.length; i++) {
+            let codePoint = source.charCodeAt(i);
+            let bytesNeeded: number;
+
+            // 处理代理对
+            if (codePoint >= 0xD800 && codePoint <= 0xDBFF && i + 1 < source.length) {
+                const next = source.charCodeAt(i + 1);
+                if (next >= 0xDC00 && next <= 0xDFFF) {
+                    codePoint = 0x10000 + ((codePoint - 0xD800) << 10) + (next - 0xDC00);
+                }
+            }
+
+            // 计算所需字节数
+            if (codePoint < 0x80) {
+                bytesNeeded = 1;
+            } else if (codePoint < 0x800) {
+                bytesNeeded = 2;
+            } else if (codePoint < 0x10000) {
+                bytesNeeded = 3;
+            } else {
+                bytesNeeded = 4;
+            }
+
+            // 检查是否有足够空间
+            if (written + bytesNeeded > destination.length) {
+                break;
+            }
+
+            // 写入字节
+            if (codePoint < 0x80) {
+                destination[written++] = codePoint;
+            } else if (codePoint < 0x800) {
+                destination[written++] = 0xC0 | (codePoint >> 6);
+                destination[written++] = 0x80 | (codePoint & 0x3F);
+            } else if (codePoint < 0x10000) {
+                destination[written++] = 0xE0 | (codePoint >> 12);
+                destination[written++] = 0x80 | ((codePoint >> 6) & 0x3F);
+                destination[written++] = 0x80 | (codePoint & 0x3F);
+            } else {
+                destination[written++] = 0xF0 | (codePoint >> 18);
+                destination[written++] = 0x80 | ((codePoint >> 12) & 0x3F);
+                destination[written++] = 0x80 | ((codePoint >> 6) & 0x3F);
+                destination[written++] = 0x80 | (codePoint & 0x3F);
+            }
+
+            read++;
+            // 如果处理了代理对，跳过低代理项
+            if (codePoint >= 0x10000) {
+                read++;
+                i++;
+            }
+        }
+
+        return { read, written };
+    }
+}
+
+/**
+ * 安装 TextEncoder polyfill
+ *
+ * 如果当前环境不支持 TextEncoder，则安装 polyfill
+ *
+ * @returns 是否安装了 polyfill
+ */
+export function installTextEncoderPolyfill(): boolean {
+    if (typeof globalThis.TextEncoder === 'undefined') {
+        (globalThis as any).TextEncoder = TextEncoderPolyfill;
+        console.log('[Polyfill] TextEncoder 已安装');
+        return true;
+    }
+    return false;
+}
+
+/**
+ * 检查 TextEncoder 是否可用（原生或 polyfill）
+ *
+ * @returns 是否可用
+ */
+export function isTextEncoderAvailable(): boolean {
+    return typeof globalThis.TextEncoder !== 'undefined';
+}
+
+export { TextEncoderPolyfill };

packages/engine/platform-common/src/polyfills/index.ts

@@ -0,0 +1,58 @@
+/**
+ * 平台 polyfills
+ *
+ * 提供跨平台兼容性支持，用于填补不同平台的 API 差异
+ */
+
+export {
+    TextDecoderPolyfill,
+    installTextDecoderPolyfill,
+    isTextDecoderAvailable
+} from './TextDecoderPolyfill';
+
+export {
+    TextEncoderPolyfill,
+    installTextEncoderPolyfill,
+    isTextEncoderAvailable
+} from './TextEncoderPolyfill';
+
+import { installTextDecoderPolyfill } from './TextDecoderPolyfill';
+import { installTextEncoderPolyfill } from './TextEncoderPolyfill';
+
+/**
+ * 安装当前平台所需的所有 polyfills
+ *
+ * @returns 已安装的 polyfill 列表
+ */
+export function installAllPolyfills(): { installed: string[] } {
+    const installed: string[] = [];
+
+    if (installTextDecoderPolyfill()) {
+        installed.push('TextDecoder');
+    }
+
+    if (installTextEncoderPolyfill()) {
+        installed.push('TextEncoder');
+    }
+
+    return { installed };
+}
+
+/**
+ * 检查当前平台需要哪些 polyfills
+ *
+ * @returns 需要的 polyfill 名称列表
+ */
+export function getRequiredPolyfills(): string[] {
+    const required: string[] = [];
+
+    if (typeof globalThis.TextDecoder === 'undefined') {
+        required.push('TextDecoder');
+    }
+
+    if (typeof globalThis.TextEncoder === 'undefined') {
+        required.push('TextEncoder');
+    }
+
+    return required;
+}