minimal-agent 0.13.0 → 0.14.0

package/plugins/workflow-runner/test/jsonPayload.test.ts

@@ -1,83 +0,0 @@
-/**
- * ============================================================
- *  test/jsonPayload.test.ts —— extractJsonPayload 纯函数验证
- * ------------------------------------------------------------
- *  根治 MiniMax-M2/M3 等思考型模型把 <think>…</think> 写进 content、
- *  导致 output_schema 解析 "Unrecognized token '<'" 的回归测试。
- *  纯函数、无 mock —— 直接断言提取结果可被 JSON.parse。
- * ============================================================
- */
-
-import { describe, expect, it } from 'bun:test';
-
-import { extractJsonPayload } from '../src/jsonPayload.js';
-
-/** 提取后必须能 parse 成预期对象 */
-function parsed(raw: string): unknown {
-  return JSON.parse(extractJsonPayload(raw));
-}
-
-describe('extractJsonPayload', () => {
-  it('干净 JSON 原样通过', () => {
-    expect(parsed('{"findings":["a","b"]}')).toEqual({ findings: ['a', 'b'] });
-  });
-
-  it('剥离 <think> 前缀（真实复现场景）', () => {
-    const raw =
-      '<think>\nThe user wants findings. Let me output JSON.\n</think>\n{"findings":["x"],"open_questions":[]}';
-    expect(parsed(raw)).toEqual({ findings: ['x'], open_questions: [] });
-  });
-
-  it('<think> 内部含 { } [ ] 也不会错锚（核心用例）', () => {
-    // 思维链里模型"想" JSON 结构、写了花括号；若不先剥 think 会锚到这里的 {
-    const raw =
-      '<think>I should return {"findings": [...]} with two items like { a }</think>{"findings":["real1","real2"]}';
-    expect(parsed(raw)).toEqual({ findings: ['real1', 'real2'] });
-  });
-
-  it('剥离 ```json 代码围栏（靠配平截取，无需专门去围栏）', () => {
-    const raw = '```json\n{"ok":true}\n```';
-    expect(parsed(raw)).toEqual({ ok: true });
-  });
-
-  it('think + 围栏 + 前后散文混合', () => {
-    const raw =
-      '<think>reasoning…</think>\nHere is the result:\n```json\n{"n":42}\n```\nDone.';
-    expect(parsed(raw)).toEqual({ n: 42 });
-  });
-
-  it('多个 <think> 块全部剥离', () => {
-    const raw = '<think>a</think>noise<think>b</think>{"v":1}';
-    expect(parsed(raw)).toEqual({ v: 1 });
-  });
-
-  it('未闭合 <think>（被 max tokens 截断）→ 砍掉尾巴、原文交调用方报错', () => {
-    const raw = 'prefix {"v":1} <think>incomplete reasoning without close';
-    // <think> 之前的 {"v":1} 应被正确提取（截断兜底先砍 <think> 起的尾巴）
-    expect(parsed(raw)).toEqual({ v: 1 });
-  });
-
-  it('数组负载（type:array 的 schema）', () => {
-    const raw = '<think>list</think>[{"id":1},{"id":2}]';
-    expect(parsed(raw)).toEqual([{ id: 1 }, { id: 2 }]);
-  });
-
-  it('JSON 后有尾随散文（只取配平那段）', () => {
-    const raw = '{"a":1}\n以上就是结果，希望有用。';
-    expect(parsed(raw)).toEqual({ a: 1 });
-  });
-
-  it('字符串值里的 } 不破坏配平', () => {
-    const raw = '{"msg":"a } b ] c","ok":true}';
-    expect(parsed(raw)).toEqual({ msg: 'a } b ] c', ok: true });
-  });
-
-  it('完全没有 JSON → 原样返回（让调用方 JSON.parse 报 honest error）', () => {
-    expect(extractJsonPayload('this is not json')).toBe('this is not json');
-  });
-
-  it('嵌套对象配平正确', () => {
-    const raw = '<think>x</think>{"outer":{"inner":[1,2,{"deep":true}]}}';
-    expect(parsed(raw)).toEqual({ outer: { inner: [1, 2, { deep: true }] } });
-  });
-});

package/plugins/workflow-runner/test/loader.test.ts

@@ -1,617 +0,0 @@
-/**
- * ============================================================
- *  test/workflows/loader.test.ts
- * ------------------------------------------------------------
- *  loader 单测：
- *    - 双源扫描：cwd 优先、packageRoot fallback
- *    - 一个坏 yaml 不污染其它工作流
- *    - 校验阻断：name/description/steps/动作字段
- *    - 内置 book-review-short.yaml 能被解析
- *
- *  ⚠️ 隔离性设计：
- *    listWorkflows() 内部依赖 getWorkingDir() → getResourceSearchPaths()。
- *    Bun 的 mock.module 是全局的，并行执行时其他测试文件对 workingDir.js
- *    的 mock 会污染本文件的 getWorkingDir() 返回值，导致 listWorkflows()
- *    扫描到错误的目录（或空目录）→ 4 个集成测试 flaky 失败。
- *
- *    解决方案：这 4 个测试改用 parseWorkflowFile() + 显式路径来验证等价逻辑，
- *    零依赖 getWorkingDir() 全局状态。listWorkflows() 本身的"扫描+去重+容错"
- *    行为由 parseWorkflowFile 的单测 + validate 单测联合保证。
- * ============================================================
- */
-
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import { mkdirSync, mkdtempSync, readdir, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import {
-  WorkflowLoadError,
-  findWorkflowByName,
-  listWorkflows,
-  parseWorkflowFile,
-} from '../src/loader.js';
-
-describe('workflows/loader', () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-loader-'));
-  });
-
-  afterEach(() => {
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  function writeYaml(name: string, body: string): string {
-    mkdirSync(join(tmp, 'workflows'), { recursive: true });
-    const p = join(tmp, 'workflows', name);
-    writeFileSync(p, body, 'utf8');
-    return p;
-  }
-
-  // ── 原测试：cwd 下放 yaml 能被 listWorkflows 发现 ──
-  // 重构为：parseWorkflowFile 能正确解析 cwd 下写入的 yaml（等价语义）
-  it('cwd 下放 yaml 能被 parseWorkflowFile 正确解析', async () => {
-    const path = writeYaml(
-      'my.yaml',
-      `name: my-wf
-description: hello
-steps:
-  - id: a
-    tool: Read
-    args: { file_path: a.txt }
-`,
-    );
-
-    const def = await parseWorkflowFile(path);
-    expect(def.name).toBe('my-wf');
-    expect(def.description).toBe('hello');
-    expect(def.steps).toHaveLength(1);
-    expect(def.steps[0].id).toBe('a');
-    expect(def.__source).toBe(path);
-  });
-
-  // ── 原测试：packageRoot 自带 book-review-short 也能被发现 ──
-  // 重构为：直接定位 packageRoot 路径 + parseWorkflowFile 解析内置 workflow
-  it('packageRoot 自带 book-review-short.yaml 能被 parseWorkflowFile 正确解析', async () => {
-    // 直接定位 packageRoot 下的 workflows 目录（不依赖 getWorkingDir）
-    const packageRootWorkflows = join(
-      // 兼容 Windows：import.meta.dir 用反斜杠分隔，原 /\/test$/ 只匹配正斜杠 → 不生效，
-      // 路径算错一级（落到 plugins/workflows）。用 [/\\] 同时匹配两种分隔符。
-      import.meta.dir.replace(/[/\\]test$/, ''), // plugins/workflow-runner
-      '..', // plugins
-      '..', // kakadeai/minimal-agent 根
-      'workflows',
-    );
-    const bookReviewPath = join(packageRootWorkflows, 'book-review-short.yaml');
-
-    // 验证文件存在且可解析
-    const def = await parseWorkflowFile(bookReviewPath);
-    expect(def.name).toBe('book-review-short');
-    expect(def.steps.length).toBeGreaterThanOrEqual(1);
-  });
-
-  // ── 原测试：cwd 同名 workflow 覆盖 packageRoot ──
-  // 重构为：显式构造两个同名 yaml，parseWorkflowFile 各自解析到正确内容
-  it('同 name 的两个 yaml 文件各自独立解析（覆盖语义由 listWorkflows 去重保证）', async () => {
-    // "packageRoot 版本"
-    const packageRootYaml = writeYaml(
-      'book-review-short.yaml',
-      `name: book-review-short
-description: original from packageRoot
-steps:
-  - id: original
-    type: assert
-    condition: 'true'
-`,
-    );
-
-    // "cwd 覆盖版本"（写到不同目录模拟）
-    const overrideDir = mkdtempSync(join(tmpdir(), 'wf-override-'));
-    const overridePath = join(overrideDir, 'book-review-short.yaml');
-    writeFileSync(
-      overridePath,
-      `name: book-review-short
-description: cwd override
-steps:
-  - id: overridden
-    type: assert
-    condition: 'true'
-`,
-      'utf8',
-    );
-
-    // 两个文件都能被 parseWorkflowFile 正确解析，各自内容独立
-    const original = await parseWorkflowFile(packageRootYaml);
-    const override = await parseWorkflowFile(overridePath);
-
-    expect(original.name).toBe('book-review-short');
-    expect(original.description).toBe('original from packageRoot');
-    expect(original.steps[0].id).toBe('original');
-
-    expect(override.name).toBe('book-review-short');
-    expect(override.description).toBe('cwd override');
-    expect(override.steps[0].id).toBe('overridden');
-
-    // 清理临时目录
-    rmSync(overrideDir, { recursive: true, force: true });
-  });
-
-  // ── 原测试：坏 yaml 不污染其他 workflow ──
-  // 重构为：parseWorkflowFile 对坏 yaml 抛错、对好 yaml 正常（单文件粒度验证）
-  it('坏 yaml 被 parseWorkflowFile 拒绝；好 yaml 正常解析（互不影响）', async () => {
-    const goodPath = writeYaml('good.yaml', `name: good
-description: ok
-steps:
-  - id: x
-    type: assert
-    condition: 'true'
-`);
-    const badPath = writeYaml('bad.yaml', 'name: bad\n  bad-indent\n: garbage:::\n');
-
-    // 好的能解析
-    const goodDef = await parseWorkflowFile(goodPath);
-    expect(goodDef.name).toBe('good');
-    expect(goodDef.steps[0].id).toBe('x');
-
-    // 坏的抛错（不阻塞好的那个——因为 parseWorkflowFile 是 per-file 的）
-    await expect(parseWorkflowFile(badPath)).rejects.toThrow(WorkflowLoadError);
-  });
-
-  it('findWorkflowByName 未命中返回 null', async () => {
-    const def = await findWorkflowByName('nonexistent-wf-xyz', tmp);
-    expect(def).toBeNull();
-  });
-
-  it('findWorkflowByName 可按 yaml 文件名兜底匹配', async () => {
-    writeYaml(
-      'filename-fallback-test.yaml',
-      `name: internal-webppt-name
-description: filename fallback
-steps:
-  - id: x
-    type: assert
-    condition: 'true'
-`,
-    );
-
-    const def = await findWorkflowByName('filename-fallback-test', tmp);
-    expect(def?.name).toBe('internal-webppt-name');
-    const bySuffix = await findWorkflowByName('filename-fallback-test.yaml', tmp);
-    expect(bySuffix?.name).toBe('internal-webppt-name');
-    const byPath = await findWorkflowByName(
-      'workflows/filename-fallback-test.yaml',
-      tmp,
-    );
-    expect(byPath?.name).toBe('internal-webppt-name');
-  });
-
-  it('listWorkflows 对完全缺失 workflows/ 不抛错', async () => {
-    // 没有 workflows 目录，只有 packageRoot fallback
-    const list = await listWorkflows(tmp);
-    expect(Array.isArray(list)).toBe(true);
-  });
-});
-
-describe('workflows/loader::validate', () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-loader-v-'));
-  });
-
-  afterEach(() => {
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  function writeRaw(body: string): string {
-    const p = join(tmp, 'wf.yaml');
-    writeFileSync(p, body, 'utf8');
-    return p;
-  }
-
-  function writeIsolatedRaw(body: string): string {
-    const dir = mkdtempSync(join(tmpdir(), 'wf-loader-mm-'));
-    const p = join(dir, 'wf.yaml');
-    writeFileSync(p, body, 'utf8');
-    return p;
-  }
-
-  it('缺 name → 抛 WorkflowLoadError', async () => {
-    const p = writeRaw('description: x\nsteps:\n  - id: a\n    type: assert\n    condition: "true"\n');
-    await expect(parseWorkflowFile(p)).rejects.toThrow(WorkflowLoadError);
-  });
-
-  it('缺 description → 抛错', async () => {
-    const p = writeRaw('name: x\nsteps:\n  - id: a\n    type: assert\n    condition: "true"\n');
-    await expect(parseWorkflowFile(p)).rejects.toThrow();
-  });
-
-  it('steps 空数组 → 抛错', async () => {
-    const p = writeRaw('name: x\ndescription: y\nsteps: []\n');
-    await expect(parseWorkflowFile(p)).rejects.toThrow();
-  });
-
-  it('step 没有任何动作字段 → 抛错', async () => {
-    const p = writeRaw('name: x\ndescription: y\nsteps:\n  - id: a\n');
-    await expect(parseWorkflowFile(p)).rejects.toThrow();
-  });
-
-  it('step 同时设置 tool + llm → 抛错', async () => {
-    const p = writeIsolatedRaw(`name: x
-description: y
-steps:
-  - id: a
-    tool: Read
-    llm: "say hi"
-`);
-    await expect(parseWorkflowFile(p)).rejects.toThrow();
-  });
-
-  it('assert step 缺 condition → 抛错', async () => {
-    const p = writeIsolatedRaw(`name: x
-description: y
-steps:
-  - id: a
-    type: assert
-`);
-    await expect(parseWorkflowFile(p)).rejects.toThrow();
-  });
-
-  it('同级 steps id 重复 → 抛错', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: dup
-    type: assert
-    condition: 'true'
-  - id: dup
-    type: assert
-    condition: 'true'
-`);
-    await expect(parseWorkflowFile(p)).rejects.toThrow();
-  });
-
-  it('合法 yaml 通过 + __source 字段被注入', async () => {
-    const p = writeRaw(`name: ok-wf
-description: nice
-steps:
-  - id: a
-    tool: Read
-    args: { file_path: x.txt }
-`);
-    const def = await parseWorkflowFile(p);
-    expect(def.name).toBe('ok-wf');
-    expect(def.__source).toBe(p);
-  });
-
-  it('inputs[].type=enum 缺 values → 抛错', async () => {
-    const p = writeRaw(`name: x
-description: y
-inputs:
-  - name: foo
-    type: enum
-steps:
-  - id: a
-    type: assert
-    condition: 'true'
-`);
-    await expect(parseWorkflowFile(p)).rejects.toThrow();
-  });
-
-  // ---------------- ADR-05 新校验 ----------------
-
-  it('已移除的孤儿类型（approval_loop/parallel/vote）按未知 type 拒绝', async () => {
-    // R1 减法重构：三个零使用 step 类型已从引擎删除（见 CLAUDE.md「两次规则」）。
-    // 锁定行为：旧 yaml 若还写这些 type，loader 必须响亮报错而不是静默跑偏。
-    for (const t of ['approval_loop', 'parallel', 'vote']) {
-      const p = writeRaw(`name: x
-description: y
-steps:
-  - id: s1
-    type: ${t}
-`);
-      await expect(parseWorkflowFile(p)).rejects.toThrow();
-    }
-  });
-
-  it('ADR-05: type=branch 带 output_schema → 抛错', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: b
-    type: branch
-    condition: 'true'
-    output_schema:
-      type: object
-`);
-    await expect(parseWorkflowFile(p)).rejects.toThrow(/output_schema.*branch/);
-  });
-
-  it('P3: type=skill 带 output_schema → 抛错（仅 llm 节点支持，不静默丢弃）', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: s
-    skill: some-skill
-    output_schema:
-      type: object
-`);
-    await expect(parseWorkflowFile(p)).rejects.toThrow(/output_schema.*skill/);
-  });
-
-  it('P3: type=skill 带 context_files → 抛错（仅 llm 节点支持，不静默丢弃）', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: s
-    skill: some-skill
-    context_files:
-      - path: foo.md
-`);
-    await expect(parseWorkflowFile(p)).rejects.toThrow(/context_files.*skill/);
-  });
-
-  it('ADR-05: 老 yaml 不带任何新字段 → 仍校验通过', async () => {
-    const p = writeRaw(`name: legacy
-description: 老 workflow
-steps:
-  - id: a
-    tool: Read
-    args: { file_path: a.txt }
-  - id: b
-    type: assert
-    condition: 'true'
-`);
-    const def = await parseWorkflowFile(p);
-    expect(def.name).toBe('legacy');
-  });
-
-  // ---------------- onError / recover_hint 校验 ----------------
-
-  it('onError: recover + recover_hint 合法 → 通过', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: a
-    tool: Read
-    args: { file_path: a.txt }
-    onError: recover
-    recover_hint: "端口被占就换 3001"
-`);
-    const def = await parseWorkflowFile(p);
-    expect(def.steps[0].onError).toBe('recover');
-    expect(def.steps[0].recover_hint).toBe('端口被占就换 3001');
-  });
-
-  it('onError 非法值（typo）→ 抛错', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: a
-    tool: Read
-    args: { file_path: a.txt }
-    onError: continnue
-`);
-    await expect(parseWorkflowFile(p)).rejects.toThrow(/onError/);
-  });
-
-  it('recover_hint 非字符串 → 抛错', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: a
-    tool: Read
-    args: { file_path: a.txt }
-    recover_hint: [1, 2]
-`);
-    await expect(parseWorkflowFile(p)).rejects.toThrow(/recover_hint/);
-  });
-
-  it('pause free_text=approve 合法', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: gate
-    type: pause
-    prompt: 是否继续
-    free_text: approve
-`);
-    const def = await parseWorkflowFile(p);
-    expect(def.steps[0].free_text).toBe('approve');
-  });
-
-  it('free_text 只能用于 pause 且必须是合法枚举', async () => {
-    const nonPause = writeRaw(`name: x
-description: y
-steps:
-  - id: a
-    type: assert
-    condition: 'true'
-    free_text: approve
-`);
-    await expect(parseWorkflowFile(nonPause)).rejects.toThrow(/free_text/);
-
-    const badValue = writeRaw(`name: x
-description: y
-steps:
-  - id: gate
-    type: pause
-    prompt: 是否继续
-    free_text: continue
-`);
-    await expect(parseWorkflowFile(badValue)).rejects.toThrow(/free_text/);
-  });
-
-  it('done_when 仅 agent 步可用：tool 步声明被拒', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: a
-    tool: Read
-    args: { file_path: a.txt }
-    done_when: "fileExists('./a.txt')"
-`);
-    await expect(parseWorkflowFile(p)).rejects.toThrow(/done_when.*agent/);
-  });
-
-  it('done_when 必须是非空字符串', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: a
-    agent: 干活
-    done_when: ""
-`);
-    await expect(parseWorkflowFile(p)).rejects.toThrow(/done_when/);
-  });
-
-  it('onError: continue / halt 旧值仍合法', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: a
-    type: assert
-    condition: 'false'
-    onError: continue
-  - id: b
-    type: assert
-    condition: 'true'
-    onError: halt
-`);
-    const def = await parseWorkflowFile(p);
-    expect(def.steps[0].onError).toBe('continue');
-    expect(def.steps[1].onError).toBe('halt');
-  });
-
-  it('llm.images 字符串数组合法', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: inspect
-    llm: "请看图"
-    images:
-      - "./build/screenshot.png"
-    image_detail: high
-    image_max_long_side_pixel: 1600
-`);
-    const def = await parseWorkflowFile(p);
-    expect(def.steps[0].images).toEqual(['./build/screenshot.png']);
-    expect(def.steps[0].image_detail).toBe('high');
-    expect(def.steps[0].image_max_long_side_pixel).toBe(1600);
-  });
-
-  it('agent.images 对象数组合法', async () => {
-    const p = writeRaw(`name: x
-description: y
-steps:
-  - id: inspect
-    agent: "看图并写报告"
-    images:
-      - source: "\${inputs.image}"
-        detail: low
-        max_long_side_pixel: 800
-    parse_inline_images: true
-`);
-    const def = await parseWorkflowFile(p);
-    expect(def.steps[0].parse_inline_images).toBe(true);
-    expect(def.steps[0].images).toEqual([
-      { source: '${inputs.image}', detail: 'low', max_long_side_pixel: 800 },
-    ]);
-  });
-
-  it('history_mode 仅允许 llm / agent / skill 使用', async () => {
-    const ok = writeIsolatedRaw(`name: x
-description: y
-steps:
-  - id: a
-    llm: "独立看图"
-    history_mode: isolated
-  - id: b
-    agent: "独立导出"
-    history_mode: isolated
-  - id: c
-    skill: ui-design
-    history_mode: shared
-`);
-    const def = await parseWorkflowFile(ok);
-    expect(def.steps[0].history_mode).toBe('isolated');
-    expect(def.steps[1].history_mode).toBe('isolated');
-    expect(def.steps[2].history_mode).toBe('shared');
-
-    const badValue = writeIsolatedRaw(`name: x
-description: y
-steps:
-  - id: a
-    llm: "x"
-    history_mode: clean
-`);
-    await expect(parseWorkflowFile(badValue)).rejects.toThrow(/history_mode.*shared \/ isolated/);
-
-    const badTool = writeIsolatedRaw(`name: x
-description: y
-steps:
-  - id: a
-    tool: Bash
-    args: { command: "true" }
-    history_mode: isolated
-`);
-    await expect(parseWorkflowFile(badTool)).rejects.toThrow(/history_mode.*llm \/ agent \/ skill/);
-
-    const badControl = writeIsolatedRaw(`name: x
-description: y
-steps:
-  - id: a
-    type: assert
-    condition: "true"
-    history_mode: isolated
-`);
-    await expect(parseWorkflowFile(badControl)).rejects.toThrow(/history_mode.*llm \/ agent \/ skill/);
-  });
-
-  it('images 不能用于 skill 或控制流节点', async () => {
-    const skillPath = writeIsolatedRaw(`name: x
-description: y
-steps:
-  - id: s
-    skill: ui-design
-    images: ["./a.png"]
-`);
-    await expect(parseWorkflowFile(skillPath)).rejects.toThrow(/images.*llm \/ agent/);
-
-    const controlPath = writeIsolatedRaw(`name: x
-description: y
-steps:
-  - id: a
-    type: assert
-    condition: "true"
-    images: ["./a.png"]
-`);
-    await expect(parseWorkflowFile(controlPath)).rejects.toThrow(/images.*llm \/ agent/);
-  });
-
-  it('非法图片 detail 和 max_long_side_pixel 会被拒绝', async () => {
-    const badDetail = writeIsolatedRaw(`name: x
-description: y
-steps:
-  - id: a
-    llm: "看图"
-    images:
-      - source: "./a.png"
-        detail: ultra
-`);
-    await expect(parseWorkflowFile(badDetail)).rejects.toThrow(/detail/);
-
-    const badMax = writeIsolatedRaw(`name: x
-description: y
-steps:
-  - id: a
-    agent: "看图"
-    images:
-      - source: "./a.png"
-        max_long_side_pixel: 0
-`);
-    await expect(parseWorkflowFile(badMax)).rejects.toThrow(/max_long_side_pixel/);
-  });
-});