@doki-land/dejavu-engine 0.0.13 → 0.0.15

package/dist/runtime/errors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Structured runtime error for generated AOT modules.
+ *
+ * Generated code never throws a bare `Error`: every failure carries the stable
+ * diagnostic `code`, the `render` stage, structured `args` and a human-readable
+ * message so hosts can classify errors without parsing `message`.
+ */
+export declare class DejavuRuntimeError extends Error {
+    readonly code: string;
+    readonly stage = "render";
+    readonly args: Record<string, unknown>;
+    constructor(code: string, detail?: string, args?: Record<string, unknown>);
+}
+/** Build a structured render error. */
+export declare function runtimeError(code: string, detail?: string, args?: Record<string, unknown>): DejavuRuntimeError;

package/dist/runtime/errors.js

@@ -0,0 +1,22 @@
+/**
+ * Structured runtime error for generated AOT modules.
+ *
+ * Generated code never throws a bare `Error`: every failure carries the stable
+ * diagnostic `code`, the `render` stage, structured `args` and a human-readable
+ * message so hosts can classify errors without parsing `message`.
+ */
+export class DejavuRuntimeError extends Error {
+    code;
+    stage = "render";
+    args;
+    constructor(code, detail, args) {
+        super(detail ? `${code}: ${detail}` : code);
+        this.name = "DejavuRuntimeError";
+        this.code = code;
+        this.args = args ?? {};
+    }
+}
+/** Build a structured render error. */
+export function runtimeError(code, detail, args) {
+    return new DejavuRuntimeError(code, detail, args);
+}

package/dist/runtime/filter.d.ts

@@ -1,9 +1,20 @@
 /**
  * Dejavu 1.0 合同过滤器集。
  *
- * 与 Rust `dejavu-ir` 的 `apply_filter` 逐项对齐，所有字符串强制转换都走
+ * 与 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,21 +1,43 @@
 import { htmlEscape } from "./escape.js";
+import { runtimeError } from "./errors.js";
 import { valueToString } from "./value.js";
-/**
- * Dejavu 1.0 合同过滤器集。
- *
- * 与 Rust `dejavu-ir` 的 `apply_filter` 逐项对齐，所有字符串强制转换都走
- * `valueToString`（null → ""），不使用 JS 的 `String()`。
- *
- * 未识别的过滤器 **宽松返回原值**（与 Rust 渲染器一致，不抛错）。
- */
+/** 与 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 runtimeError("dejavu.template.unknown-filter", name, { filter: name });
+    }
+    if (args.length < spec.minArgs || args.length > spec.maxArgs) {
+        throw runtimeError("dejavu.template.filter-arity", `${spec.name} expects ` +
+            `${spec.minArgs}..${spec.maxArgs} argument(s), got ${args.length}`, {
+            filter: spec.name,
+            minArgs: spec.minArgs,
+            maxArgs: spec.maxArgs,
+            got: args.length,
+        });
+    }
     switch (name) {
         case "escape":
         case "e":
             return htmlEscape(valueToString(value));
         case "raw":
         case "safe":
-        case "s":
             return value;
         case "uppercase":
         case "upper":
@@ -60,7 +82,8 @@ export function applyFilter(name, value, args) {
         case "slug":
             return slugify(valueToString(value));
         default:
-            return value;
+            // Unreachable: `filterSpec` already rejected unknown names.
+            throw runtimeError("dejavu.template.unknown-filter", name);
     }
 }
 /**

package/dist/runtime/function.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Dejavu `function` 命名空间：语言中立的静态表 + 纯函数实现。
+ *
+ * 与 Rust `dejavu_ir::registry::FUNCTIONS` 和 `builtins::call_function` 对齐。
+ * 仅允许 `name(args)` 形式的裸标识符调用；成员调用与未知名字一律报错。
+ */
+export interface FunctionSpec {
+    name: string;
+    aliases: string[];
+    minArgs: number;
+    maxArgs: number;
+    capability: string;
+}
+/** 与 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,91 @@
+/**
+ * Dejavu `function` 命名空间：语言中立的静态表 + 纯函数实现。
+ *
+ * 与 Rust `dejavu_ir::registry::FUNCTIONS` 和 `builtins::call_function` 对齐。
+ * 仅允许 `name(args)` 形式的裸标识符调用；成员调用与未知名字一律报错。
+ */
+import { runtimeError } from "./errors.js";
+/** 与 Rust `dejavu_ir::registry::FUNCTIONS` 同序同构的静态描述。 */
+export const FUNCTIONS = [
+    { name: "range", aliases: [], minArgs: 2, maxArgs: 3, capability: "pure" },
+    { name: "min", aliases: [], minArgs: 2, maxArgs: 2, capability: "pure" },
+    { name: "max", aliases: [], minArgs: 2, maxArgs: 2, capability: "pure" },
+];
+/** `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 runtimeError("dejavu.template.unknown-function", name, { function: name });
+    }
+    if (args.length < spec.minArgs || args.length > spec.maxArgs) {
+        throw runtimeError("dejavu.template.function-arity", `${spec.name} expects ` +
+            `${spec.minArgs}..${spec.maxArgs} argument(s), got ${args.length}`, {
+            function: spec.name,
+            minArgs: spec.minArgs,
+            maxArgs: spec.maxArgs,
+            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 runtimeError("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,9 @@
  * 与 Rust `dejavu-codegen` Node stub 以及 `dejavu-types` 的 filter 系统语义一致。
  */
 export { htmlEscape } from "./escape.js";
+export { DejavuRuntimeError, runtimeError } from "./errors.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,9 @@
  * 与 Rust `dejavu-codegen` Node stub 以及 `dejavu-types` 的 filter 系统语义一致。
  */
 export { htmlEscape } from "./escape.js";
+export { DejavuRuntimeError, runtimeError } from "./errors.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,19 @@
+/**
+ * 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;
+    capability: string;
+}
+/** 与 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,87 @@
+/**
+ * Dejavu `test` 命名空间：语言中立的谓词表 + 纯函数实现。
+ *
+ * 与 Rust `dejavu_ir::registry::TESTS` 和 `builtins::call_test` 对齐。
+ * 语法为 `expr is name` / `expr is not name` / `expr is name(args)`，
+ * 本文件只负责对已求值的左值执行谓词。
+ */
+import { runtimeError } from "./errors.js";
+import { isTruthy } from "./value.js";
+/** 与 Rust `dejavu_ir::registry::TESTS` 同序同构的静态描述。 */
+export const TESTS = [
+    { name: "null", aliases: ["none"], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "truthy", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "empty", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "array", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "object", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "string", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "number", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "boolean", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "even", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+    { name: "odd", aliases: [], minArgs: 0, maxArgs: 0, capability: "pure" },
+];
+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 runtimeError("dejavu.template.unknown-test", name, { test: name });
+    }
+    if (args.length < spec.minArgs || args.length > spec.maxArgs) {
+        throw runtimeError("dejavu.template.test-arity", `${spec.name} expects ` +
+            `${spec.minArgs}..${spec.maxArgs} argument(s), got ${args.length}`, {
+            test: spec.name,
+            minArgs: spec.minArgs,
+            maxArgs: spec.maxArgs,
+            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 runtimeError("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/package.json

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