@doki-land/dejavu-engine 0.0.12 → 0.0.14

package/dist/runtime/expr.d.ts

@@ -1,23 +1,23 @@
 /**
  * Dejavu 1.0 支持的二元运算符。
- * 与 Rust `dejavu-ir::IrExprBinaryOp` 枚举一一对应。
+ * 与 Rust `dejavu-ir` 的 `eval_binary` 一一对应，**不借用 JS 隐式转换**：
  *
- * 行为：
- * - `+` 特殊：任何一侧为字符串时做字符串拼接，否则数值加法。
- * - `&&` / `||` 返回原值（短路），不是布尔。
- * - `in`：R 是 object / array 时检查 key 存在。
- * - 比较与相等用 JS 原生语义。
+ * - `+`：两侧都是 number 时相加，否则按 `valueToString` 做字符串拼接。
+ * - `-` `*` `/` `%`：只接受 number，非 number 或结果非有限数 → null。
+ * - `==` / `!=`：结构相等（见 `valuesEqual`），不做类型转换。
+ * - `<` `<=` `>` `>=`：两侧都是 number 才比较，否则 false。
+ * - `&&` / `||`：返回 **boolean**（Dejavu truthiness），不是原值。
+ * - `in`：数组按成员、字符串按子串、对象按 key 判断。
  */
 export declare function binary(op: string, l: unknown, r: unknown): unknown;
 /**
- * 一元运算符。
+ * 一元运算符 —— 与 Rust `eval_unary` 对齐。
  *
- * `!` 使用 **Dejavu truthiness**（不是 JS falsy）。
+ * `!` 使用 Dejavu truthiness；`-` 只接受 number；`+` 是恒等。
  */
 export declare function unary(op: string, a: unknown): unknown;
 /**
- * 成员访问 —— `obj?.[property] ?? null`。
- * 对不存在的键返回 null（不是 undefined）。
+ * 成员访问 —— 对不存在的键返回 null（不是 undefined）。
  */
 export declare function exprMember(obj: unknown, property: string): unknown;
 /**

package/dist/runtime/expr.js

@@ -1,81 +1,100 @@
-import { isTruthy } from "./value.js";
+import { isTruthy, valueToString, valuesEqual } from "./value.js";
 /**
  * Dejavu 1.0 支持的二元运算符。
- * 与 Rust `dejavu-ir::IrExprBinaryOp` 枚举一一对应。
+ * 与 Rust `dejavu-ir` 的 `eval_binary` 一一对应，**不借用 JS 隐式转换**：
  *
- * 行为：
- * - `+` 特殊：任何一侧为字符串时做字符串拼接，否则数值加法。
- * - `&&` / `||` 返回原值（短路），不是布尔。
- * - `in`：R 是 object / array 时检查 key 存在。
- * - 比较与相等用 JS 原生语义。
+ * - `+`：两侧都是 number 时相加，否则按 `valueToString` 做字符串拼接。
+ * - `-` `*` `/` `%`：只接受 number，非 number 或结果非有限数 → null。
+ * - `==` / `!=`：结构相等（见 `valuesEqual`），不做类型转换。
+ * - `<` `<=` `>` `>=`：两侧都是 number 才比较，否则 false。
+ * - `&&` / `||`：返回 **boolean**（Dejavu truthiness），不是原值。
+ * - `in`：数组按成员、字符串按子串、对象按 key 判断。
  */
 export function binary(op, l, r) {
     switch (op) {
         case "+": {
-            if (typeof l === "string" || typeof r === "string") {
-                return String(l) + String(r);
+            if (typeof l === "number" && typeof r === "number") {
+                return finite(l + r);
             }
-            return l + r;
+            return valueToString(l) + valueToString(r);
         }
         case "-":
-            return l - r;
         case "*":
-            return l * r;
         case "/":
-            return l / r;
-        case "%":
-            return l % r;
+        case "%": {
+            if (typeof l !== "number" || typeof r !== "number")
+                return null;
+            const value = op === "-"
+                ? l - r
+                : op === "*"
+                    ? l * r
+                    : op === "/"
+                        ? l / r
+                        : l % r;
+            return finite(value);
+        }
         case "==":
-            // Dejavu 1.0 只用 ==/!= —— JS 宽松相等
-            // eslint-disable-next-line eqeqeq
-            return l == r;
+            return valuesEqual(l, r);
         case "!=":
-            // eslint-disable-next-line eqeqeq
-            return l != r;
-        case "===":
-            return l === r;
-        case "!==":
-            return l !== r;
+            return !valuesEqual(l, r);
         case "<":
-            return l < r;
         case "<=":
-            return l <= r;
         case ">":
-            return l > r;
-        case ">=":
-            return l >= r;
+        case ">=": {
+            if (typeof l !== "number" || typeof r !== "number")
+                return false;
+            if (!Number.isFinite(l) || !Number.isFinite(r))
+                return false;
+            switch (op) {
+                case "<":
+                    return l < r;
+                case "<=":
+                    return l <= r;
+                case ">":
+                    return l > r;
+                default:
+                    return l >= r;
+            }
+        }
         case "&&":
-            return l && r;
+            return isTruthy(l) && isTruthy(r);
         case "||":
-            return l || r;
+            return isTruthy(l) || isTruthy(r);
         case "in":
-            if (r === null || r === undefined)
-                return false;
-            return String(l) in r;
+            if (Array.isArray(r))
+                return r.some((item) => valuesEqual(item, l));
+            if (typeof r === "string")
+                return r.includes(valueToString(l));
+            if (r !== null && typeof r === "object") {
+                return Object.prototype.hasOwnProperty.call(r, valueToString(l));
+            }
+            return false;
         default:
             return null;
     }
 }
+function finite(value) {
+    return Number.isFinite(value) ? value : null;
+}
 /**
- * 一元运算符。
+ * 一元运算符 —— 与 Rust `eval_unary` 对齐。
  *
- * `!` 使用 **Dejavu truthiness**（不是 JS falsy）。
+ * `!` 使用 Dejavu truthiness；`-` 只接受 number；`+` 是恒等。
  */
 export function unary(op, a) {
     switch (op) {
         case "!":
             return !isTruthy(a);
         case "-":
-            return -(Number(a) || 0);
+            return typeof a === "number" ? finite(-a) : null;
         case "+":
-            return +(Number(a) || 0);
+            return a;
         default:
             return null;
     }
 }
 /**
- * 成员访问 —— `obj?.[property] ?? null`。
- * 对不存在的键返回 null（不是 undefined）。
+ * 成员访问 —— 对不存在的键返回 null（不是 undefined）。
  */
 export function exprMember(obj, property) {
     if (obj === null || obj === undefined)

package/dist/runtime/filter.d.ts

@@ -1,9 +1,20 @@
 /**
  * Dejavu 1.0 合同过滤器集。
  *
- * 与 Rust `dejavu-types` 过滤器系统（见 `projects/crates/dejavu-types/src/values/filter.rs`）
- * 以及 `dejavu-codegen` Node stub 对齐。
+ * 与 Rust `dejavu-ir` 的 `registry` 逐项对齐，所有字符串强制转换都走
+ * `valueToString`（null → ""），不使用 JS 的 `String()`。
  *
- * 未识别的过滤器 **宽松返回原值**（与 Rust 渲染器一致，不抛错）。
+ * 未识别的过滤器与参数个数违约都抛错，与 Rust 渲染器一致。
  */
+export type FilterCapability = "pure" | "safe-output";
+export interface FilterSpec {
+    name: string;
+    aliases: string[];
+    minArgs: number;
+    maxArgs: number;
+    capability: FilterCapability;
+}
+/** 与 Rust `dejavu_ir::registry::FILTERS` 同序同构的静态描述。 */
+export declare const FILTERS: readonly FilterSpec[];
+export declare function filterSpec(name: string): FilterSpec | undefined;
 export declare function applyFilter(name: string, value: unknown, args: unknown[]): unknown;

package/dist/runtime/filter.js

@@ -1,71 +1,118 @@
 import { htmlEscape } from "./escape.js";
-import { isTruthy, valueToString } from "./value.js";
-/**
- * Dejavu 1.0 合同过滤器集。
- *
- * 与 Rust `dejavu-types` 过滤器系统（见 `projects/crates/dejavu-types/src/values/filter.rs`）
- * 以及 `dejavu-codegen` Node stub 对齐。
- *
- * 未识别的过滤器 **宽松返回原值**（与 Rust 渲染器一致，不抛错）。
- */
+import { valueToString } from "./value.js";
+/** 与 Rust `dejavu_ir::registry::FILTERS` 同序同构的静态描述。 */
+export const FILTERS = [
+    { name: "uppercase", aliases: ["upper"], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "lowercase", aliases: ["lower"], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "trim", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "default", aliases: [], minArgs: 1, maxArgs: 1, capability: "pure" },
+    { name: "length", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "join", aliases: [], minArgs: 0, maxArgs: 1, capability: "pure" },
+    { name: "replace", aliases: [], minArgs: 2, maxArgs: 2, capability: "pure" },
+    { name: "escape", aliases: ["e"], minArgs: 0, maxArgs: 0, capability: "safe-output" },
+    { name: "safe", aliases: ["raw"], minArgs: 0, maxArgs: 0, capability: "safe-output" },
+    { name: "date", aliases: [], minArgs: 0, maxArgs: 1, capability: "pure" },
+    { name: "slug", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+];
+export function filterSpec(name) {
+    return FILTERS.find((spec) => spec.name === name || spec.aliases.includes(name));
+}
 export function applyFilter(name, value, args) {
+    const spec = filterSpec(name);
+    if (!spec) {
+        throw new Error(`dejavu.template.unknown-filter: ${name}`);
+    }
+    if (args.length < spec.minArgs || args.length > spec.maxArgs) {
+        throw new Error(`dejavu.template.filter-arity: ${spec.name} expects ` +
+            `${spec.minArgs}..${spec.maxArgs} argument(s), got ${args.length}`);
+    }
     switch (name) {
         case "escape":
         case "e":
             return htmlEscape(valueToString(value));
         case "raw":
         case "safe":
-        case "s":
-            return valueToString(value);
+            return value;
         case "uppercase":
         case "upper":
-            return String(value).toUpperCase();
+            return valueToString(value).toUpperCase();
         case "lowercase":
         case "lower":
-            return String(value).toLowerCase();
+            return valueToString(value).toLowerCase();
         case "trim":
-            return String(value).trim();
-        case "default":
-            return isTruthy(value) ? value : args[0] ?? "";
+            return valueToString(value).trim();
+        case "default": {
+            // 只有 null 与空串算缺失 —— 0 / false / [] 保留原值。
+            if (value === null || value === undefined || value === "") {
+                return args[0] ?? null;
+            }
+            return value;
+        }
         case "length": {
-            if (value === null || value === undefined)
-                return 0;
-            if (Array.isArray(value))
-                return value.length;
             if (typeof value === "string")
+                return [...value].length;
+            if (Array.isArray(value))
                 return value.length;
-            const maybe = value.length;
-            return typeof maybe === "number" ? maybe : String(value).length;
+            if (value !== null && typeof value === "object") {
+                return Object.keys(value).length;
+            }
+            return 0;
         }
-        case "join":
+        case "join": {
+            const sep = valueToString(args[0] ?? ",");
             return Array.isArray(value)
-                ? value.join(String(args[0] ?? ","))
-                : String(value);
-        case "replace":
-            return String(value).replace(args[0] ?? "", String(args[1] ?? ""));
+                ? value.map(valueToString).join(sep)
+                : valueToString(value);
+        }
+        case "replace": {
+            const from = valueToString(args[0] ?? "");
+            const to = valueToString(args[1] ?? "");
+            return valueToString(value).split(from).join(to);
+        }
         case "date": {
-            let d = null;
-            if (value instanceof Date) {
-                d = value;
-            }
-            else if (typeof value === "number") {
-                d = new Date(value);
-            }
-            else if (typeof value === "string") {
-                const parsed = new Date(value);
-                if (!Number.isNaN(parsed.getTime()))
-                    d = parsed;
-            }
-            if (!d)
-                return "";
-            // 第一期只支持 ISO 8601（args[0] 不使用 —— Rust 过滤器默认也是 ISO）。
-            return d.toISOString();
+            const pattern = valueToString(args[0] ?? "%Y-%m-%d");
+            return formatDate(valueToString(value), pattern);
         }
         case "slug":
-            return slugify(String(value));
+            return slugify(valueToString(value));
         default:
-            return value;
+            // Unreachable: `filterSpec` already rejected unknown names.
+            throw new Error(`dejavu.template.unknown-filter: ${name}`);
+    }
+}
+/**
+ * 与 Rust `format_date` 对齐的最小 strftime：`%Y %m %d %H %M %S %%`。
+ *
+ * 输入：空串 → ""；`now` → 当前时间；纯数字 → epoch 毫秒；其他 → ISO 解析。
+ */
+function formatDate(input, pattern) {
+    if (input === "")
+        return "";
+    let ms;
+    if (input === "now") {
+        ms = Date.now();
+    }
+    else if (/^[0-9]+$/.test(input)) {
+        ms = Number(input);
+    }
+    else {
+        ms = Date.parse(input);
+        if (Number.isNaN(ms))
+            return "";
     }
+    if (Number.isNaN(ms))
+        return "";
+    const d = new Date(ms);
+    const pad = (n) => String(n).padStart(2, "0");
+    return pattern
+        .replaceAll("%%", "\u0000")
+        .replaceAll("%Y", String(d.getUTCFullYear()))
+        .replaceAll("%m", pad(d.getUTCMonth() + 1))
+        .replaceAll("%d", pad(d.getUTCDate()))
+        .replaceAll("%H", pad(d.getUTCHours()))
+        .replaceAll("%M", pad(d.getUTCMinutes()))
+        .replaceAll("%S", pad(d.getUTCSeconds()))
+        .replaceAll("\u0000", "%");
 }
 /**
  * 与 Rust `slug_filter` 对齐：

package/dist/runtime/function.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Dejavu `function` 命名空间：语言中立的静态表 + 纯函数实现。
+ *
+ * 与 Rust `dejavu_ir::registry::FUNCTIONS` 和 `builtins::call_function` 对齐。
+ * 仅允许 `name(args)` 形式的裸标识符调用；成员调用与未知名字一律报错。
+ */
+export interface FunctionSpec {
+    name: string;
+    aliases: string[];
+    minArgs: number;
+    maxArgs: number;
+}
+/** 与 Rust `dejavu_ir::registry::FUNCTIONS` 同序同构的静态描述。 */
+export declare const FUNCTIONS: readonly FunctionSpec[];
+export declare function functionSpec(name: string): FunctionSpec | undefined;
+export declare function callFunction(name: string, args: unknown[]): unknown;

package/dist/runtime/function.js

@@ -0,0 +1,85 @@
+/**
+ * Dejavu `function` 命名空间：语言中立的静态表 + 纯函数实现。
+ *
+ * 与 Rust `dejavu_ir::registry::FUNCTIONS` 和 `builtins::call_function` 对齐。
+ * 仅允许 `name(args)` 形式的裸标识符调用；成员调用与未知名字一律报错。
+ */
+/** 与 Rust `dejavu_ir::registry::FUNCTIONS` 同序同构的静态描述。 */
+export const FUNCTIONS = [
+    { name: "range", aliases: [], minArgs: 2, maxArgs: 3 },
+    { name: "min", aliases: [], minArgs: 2, maxArgs: 2 },
+    { name: "max", aliases: [], minArgs: 2, maxArgs: 2 },
+];
+/** `range` 允许产出的最大元素数，与 Rust `RANGE_LIMIT` 一致。 */
+const RANGE_LIMIT = 10_000;
+export function functionSpec(name) {
+    return FUNCTIONS.find((spec) => spec.name === name || spec.aliases.includes(name));
+}
+export function callFunction(name, args) {
+    const spec = functionSpec(name);
+    if (!spec) {
+        throw new Error(`dejavu.template.unknown-function: ${name}`);
+    }
+    if (args.length < spec.minArgs || args.length > spec.maxArgs) {
+        throw new Error(`dejavu.template.function-arity: ${spec.name} expects ` +
+            `${spec.minArgs}..${spec.maxArgs} argument(s), got ${args.length}`);
+    }
+    switch (spec.name) {
+        case "range":
+            return range(args);
+        case "min":
+            return numericPair(args, true);
+        case "max":
+            return numericPair(args, false);
+        default:
+            // Unreachable: `functionSpec` already rejected unknown names.
+            throw new Error(`dejavu.template.unknown-function: ${name}`);
+    }
+}
+/** `range(start, stop, step=1)`，非法输入按值模型规则返回 null。 */
+function range(args) {
+    const start = integral(args[0]);
+    if (start === undefined)
+        return null;
+    const stop = integral(args[1]);
+    if (stop === undefined)
+        return null;
+    let step = 1;
+    if (args.length > 2) {
+        const parsed = integral(args[2]);
+        if (parsed === undefined || parsed === 0)
+            return null;
+        step = parsed;
+    }
+    const out = [];
+    let current = start;
+    while ((step > 0 && current < stop) ||
+        (step < 0 && current > stop)) {
+        if (out.length >= RANGE_LIMIT)
+            return null;
+        out.push(current);
+        current += step;
+    }
+    return out;
+}
+/** `min(a, b)` / `max(a, b)`，仅接受有限数字。 */
+function numericPair(args, min) {
+    const a = finiteNumber(args[0]);
+    const b = finiteNumber(args[1]);
+    if (a === undefined || b === undefined)
+        return null;
+    return min ? Math.min(a, b) : Math.max(a, b);
+}
+function finiteNumber(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    return value;
+}
+/** 整数（与 Rust `integral` 对齐：非整数、非数字、越界都视为非法）。 */
+function integral(value) {
+    if (typeof value !== "number" || !Number.isInteger(value))
+        return undefined;
+    if (value < -(2 ** 63) || value > 2 ** 63 - 1)
+        return undefined;
+    return value;
+}

package/dist/runtime/index.d.ts

@@ -5,6 +5,8 @@
  * 与 Rust `dejavu-codegen` Node stub 以及 `dejavu-types` 的 filter 系统语义一致。
  */
 export { htmlEscape } from "./escape.js";
-export { valueToString, isTruthy } from "./value.js";
+export { valueToString, isTruthy, valuesEqual } from "./value.js";
 export { applyFilter } from "./filter.js";
+export { FUNCTIONS, functionSpec, callFunction } from "./function.js";
+export { TESTS, testSpec, applyTest } from "./test.js";
 export { binary, unary, exprMember, exprIndex } from "./expr.js";

package/dist/runtime/index.js

@@ -5,6 +5,8 @@
  * 与 Rust `dejavu-codegen` Node stub 以及 `dejavu-types` 的 filter 系统语义一致。
  */
 export { htmlEscape } from "./escape.js";
-export { valueToString, isTruthy } from "./value.js";
+export { valueToString, isTruthy, valuesEqual } from "./value.js";
 export { applyFilter } from "./filter.js";
+export { FUNCTIONS, functionSpec, callFunction } from "./function.js";
+export { TESTS, testSpec, applyTest } from "./test.js";
 export { binary, unary, exprMember, exprIndex } from "./expr.js";

package/dist/runtime/test.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Dejavu `test` 命名空间：语言中立的谓词表 + 纯函数实现。
+ *
+ * 与 Rust `dejavu_ir::registry::TESTS` 和 `builtins::call_test` 对齐。
+ * 语法为 `expr is name` / `expr is not name` / `expr is name(args)`，
+ * 本文件只负责对已求值的左值执行谓词。
+ */
+export interface TestSpec {
+    name: string;
+    aliases: string[];
+    minArgs: number;
+    maxArgs: number;
+}
+/** 与 Rust `dejavu_ir::registry::TESTS` 同序同构的静态描述。 */
+export declare const TESTS: readonly TestSpec[];
+export declare function testSpec(name: string): TestSpec | undefined;
+/** 对已求值的左值执行谓词；`negated` 为 `is not` 形式。 */
+export declare function applyTest(name: string, value: unknown, args: unknown[], negated?: boolean): boolean;

package/dist/runtime/test.js

@@ -0,0 +1,81 @@
+/**
+ * Dejavu `test` 命名空间：语言中立的谓词表 + 纯函数实现。
+ *
+ * 与 Rust `dejavu_ir::registry::TESTS` 和 `builtins::call_test` 对齐。
+ * 语法为 `expr is name` / `expr is not name` / `expr is name(args)`，
+ * 本文件只负责对已求值的左值执行谓词。
+ */
+import { isTruthy } from "./value.js";
+/** 与 Rust `dejavu_ir::registry::TESTS` 同序同构的静态描述。 */
+export const TESTS = [
+    { name: "null", aliases: ["none"], minArgs: 0, maxArgs: 0 },
+    { name: "truthy", aliases: [], minArgs: 0, maxArgs: 0 },
+    { name: "empty", aliases: [], minArgs: 0, maxArgs: 0 },
+    { name: "array", aliases: [], minArgs: 0, maxArgs: 0 },
+    { name: "object", aliases: [], minArgs: 0, maxArgs: 0 },
+    { name: "string", aliases: [], minArgs: 0, maxArgs: 0 },
+    { name: "number", aliases: [], minArgs: 0, maxArgs: 0 },
+    { name: "boolean", aliases: [], minArgs: 0, maxArgs: 0 },
+    { name: "even", aliases: [], minArgs: 0, maxArgs: 0 },
+    { name: "odd", aliases: [], minArgs: 0, maxArgs: 0 },
+];
+export function testSpec(name) {
+    return TESTS.find((spec) => spec.name === name || spec.aliases.includes(name));
+}
+/** 对已求值的左值执行谓词；`negated` 为 `is not` 形式。 */
+export function applyTest(name, value, args, negated = false) {
+    const spec = testSpec(name);
+    if (!spec) {
+        throw new Error(`dejavu.template.unknown-test: ${name}`);
+    }
+    if (args.length < spec.minArgs || args.length > spec.maxArgs) {
+        throw new Error(`dejavu.template.test-arity: ${spec.name} expects ` +
+            `${spec.minArgs}..${spec.maxArgs} argument(s), got ${args.length}`);
+    }
+    let result;
+    switch (spec.name) {
+        case "null":
+            result = value === null || value === undefined;
+            break;
+        case "truthy":
+            result = isTruthy(value);
+            break;
+        case "empty":
+            result =
+                value === ""
+                    || (Array.isArray(value) && value.length === 0)
+                    || (isPlainObject(value) && Object.keys(value).length === 0);
+            break;
+        case "array":
+            result = Array.isArray(value);
+            break;
+        case "object":
+            result = isPlainObject(value);
+            break;
+        case "string":
+            result = typeof value === "string";
+            break;
+        case "number":
+            result = typeof value === "number";
+            break;
+        case "boolean":
+            result = typeof value === "boolean";
+            break;
+        case "even":
+            result = isInteger(value) && value % 2 === 0;
+            break;
+        case "odd":
+            result = isInteger(value) && value % 2 !== 0;
+            break;
+        default:
+            // Unreachable: `testSpec` already rejected unknown names.
+            throw new Error(`dejavu.template.unknown-test: ${name}`);
+    }
+    return result !== negated;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isInteger(value) {
+    return typeof value === "number" && Number.isInteger(value);
+}

package/dist/runtime/value.d.ts

@@ -11,14 +11,17 @@
  */
 export declare function isTruthy(v: unknown): boolean;
 /**
- * 将任意 JS 值渲染为字符串。与 Rust 渲染器的 debug-print 语义对齐：
+ * 将任意 JS 值渲染为字符串。与 Rust `value_to_string` 对齐：
  *
  * - null / undefined → ""
  * - boolean → "true" / "false"
  * - number → String()（NaN / Infinity 保持原样）
  * - Date → toISOString()
- * - Array → 递归 valueToString 后 "," join
- * - object → JSON.stringify（fallback 到 String()）
+ * - Array / object → 紧凑 JSON（与 serde_json 输出一致）
  * - string / 其他 → String()
  */
 export declare function valueToString(v: unknown): string;
+/**
+ * 结构相等 —— 与 Rust `serde_json::Value` 的 `==` 对齐，不做类型转换。
+ */
+export declare function valuesEqual(a: unknown, b: unknown): boolean;

package/dist/runtime/value.js

@@ -26,14 +26,13 @@ export function isTruthy(v) {
     return true;
 }
 /**
- * 将任意 JS 值渲染为字符串。与 Rust 渲染器的 debug-print 语义对齐：
+ * 将任意 JS 值渲染为字符串。与 Rust `value_to_string` 对齐：
  *
  * - null / undefined → ""
  * - boolean → "true" / "false"
  * - number → String()（NaN / Infinity 保持原样）
  * - Date → toISOString()
- * - Array → 递归 valueToString 后 "," join
- * - object → JSON.stringify（fallback 到 String()）
+ * - Array / object → 紧凑 JSON（与 serde_json 输出一致）
  * - string / 其他 → String()
  */
 export function valueToString(v) {
@@ -46,9 +45,7 @@ export function valueToString(v) {
     }
     if (v instanceof Date)
         return v.toISOString();
-    if (Array.isArray(v))
-        return v.map(valueToString).join(",");
-    if (typeof v === "object") {
+    if (Array.isArray(v) || typeof v === "object") {
         try {
             return JSON.stringify(v);
         }
@@ -58,3 +55,27 @@ export function valueToString(v) {
     }
     return String(v);
 }
+/**
+ * 结构相等 —— 与 Rust `serde_json::Value` 的 `==` 对齐，不做类型转换。
+ */
+export function valuesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null || a === undefined || b === undefined)
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((v, i) => valuesEqual(v, b[i]));
+    }
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (typeof a === "object" && typeof b === "object") {
+        const ka = Object.keys(a);
+        const kb = Object.keys(b);
+        if (ka.length !== kb.length)
+            return false;
+        if (ka.some((k) => !Object.prototype.hasOwnProperty.call(b, k)))
+            return false;
+        return ka.every((k) => valuesEqual(a[k], b[k]));
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doki-land/dejavu-engine",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "Dejavu pure TypeScript AOT runtime — generated template modules depend on this package",
   "type": "module",
   "license": "MPL-2.0",