@bastani/atomic 0.5.0-3 → 0.5.0-5

package/src/commands/cli/chat/index.ts

@@ -92,14 +92,20 @@ function buildLauncherScript(
   cmd: string,
   args: string[],
   projectRoot: string,
+  envVars: Record<string, string> = {},
 ): { script: string; ext: string } {
   const isWin = process.platform === "win32";
+  const envEntries = Object.entries(envVars);
 
   if (isWin) {
     // PowerShell: use array splatting for safe arg passing
     const argList = args.map((a) => `"${escPwsh(a)}"`).join(", ");
+    const envLines = envEntries.map(
+      ([key, value]) => `$env:${key} = "${escPwsh(value)}"`,
+    );
     const script = [
       `Set-Location "${escPwsh(projectRoot)}"`,
+      ...envLines,
       argList.length > 0
         ? `& "${escPwsh(cmd)}" @(${argList})`
         : `& "${escPwsh(cmd)}"`,
@@ -111,9 +117,13 @@ function buildLauncherScript(
   const quotedArgs = args
     .map((a) => `"${escBash(a)}"`)
     .join(" ");
+  const envLines = envEntries.map(
+    ([key, value]) => `export ${key}="${escBash(value)}"`,
+  );
   const script = [
     "#!/bin/bash",
     `cd "${escBash(projectRoot)}"`,
+    ...envLines,
     `exec "${escBash(cmd)}" ${quotedArgs}`,
   ].join("\n");
   return { script, ext: "sh" };
@@ -162,15 +172,16 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
   // ── Build argv ──
   const args = buildAgentArgs(agentType, passthroughArgs);
   const cmd = [config.cmd, ...args];
+  const envVars = config.env_vars;
 
   // ── Inside tmux: spawn inline in the current pane ──
   if (isInsideTmux()) {
-    return spawnDirect(cmd, projectRoot);
+    return spawnDirect(cmd, projectRoot, envVars);
   }
 
   // ── No TTY: tmux attach requires a real terminal ──
   if (!process.stdin.isTTY) {
-    return spawnDirect(cmd, projectRoot);
+    return spawnDirect(cmd, projectRoot, envVars);
   }
 
   // ── Ensure tmux is available ──
@@ -184,7 +195,7 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
     }
     if (!isTmuxInstalled()) {
       // No tmux available — fall back to direct spawn
-      return spawnDirect(cmd, projectRoot);
+      return spawnDirect(cmd, projectRoot, envVars);
     }
   }
 
@@ -194,7 +205,12 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
 
   const sessionsDir = join(homedir(), ".atomic", "sessions", "chat");
   await mkdir(sessionsDir, { recursive: true });
-  const { script, ext } = buildLauncherScript(config.cmd, args, projectRoot);
+  const { script, ext } = buildLauncherScript(
+    config.cmd,
+    args,
+    projectRoot,
+    envVars,
+  );
   const launcherPath = join(sessionsDir, `${windowName}.${ext}`);
   await writeFile(launcherPath, script, { mode: 0o755 });
 
@@ -218,7 +234,7 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
     // If tmux attach itself failed (e.g. lost TTY), clean up and fall back
     if (exitCode !== 0) {
       try { killSession(windowName); } catch {}
-      return spawnDirect(cmd, projectRoot);
+      return spawnDirect(cmd, projectRoot, envVars);
     }
 
     return exitCode;
@@ -228,7 +244,7 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
     console.error(
       `${COLORS.yellow}Warning: Failed to create tmux session (${message}). Falling back to direct spawn.${COLORS.reset}`
     );
-    return spawnDirect(cmd, projectRoot);
+    return spawnDirect(cmd, projectRoot, envVars);
   }
 }
 
@@ -236,11 +252,15 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
  * Spawn the agent CLI directly with inherited stdio.
  * Used when not inside tmux.
  */
-async function spawnDirect(cmd: string[], projectRoot: string): Promise<number> {
+async function spawnDirect(
+  cmd: string[],
+  projectRoot: string,
+  envVars: Record<string, string> = {},
+): Promise<number> {
   const proc = Bun.spawn(cmd, {
     stdio: ["inherit", "inherit", "inherit"],
     cwd: projectRoot,
-    env: { ...process.env },
+    env: { ...process.env, ...envVars },
   });
 
   return await proc.exited;

package/src/commands/cli/init/index.ts

@@ -21,6 +21,7 @@ import {
   getAgentKeys,
   isValidAgent,
   SCM_CONFIG,
+  SCM_SKILLS_BY_TYPE,
   type SourceControlType,
   getScmKeys,
   isValidScm,
@@ -35,7 +36,6 @@ import {
   getTemplateAgentFolder,
 } from "@/services/config/atomic-global-config.ts";
 import {
-  getScmPrefix,
   installLocalScmSkills,
   reconcileScmVariants,
   syncProjectScmSkills,
@@ -167,8 +167,6 @@ interface InitOptions {
   /** Pre-selected source control type (skip SCM selection prompt) */
   preSelectedScm?: SourceControlType;
   configNotFoundMessage?: string;
-  /** Force overwrite of preserved files (bypass preservation/merge logic) */
-  force?: boolean;
   /** Auto-confirm all prompts (non-interactive mode for CI/testing) */
   yes?: boolean;
   /**
@@ -330,10 +328,7 @@ export async function initCommand(options: InitOptions = {}): Promise<void> {
   const targetFolder = join(targetDir, agent.folder);
   const folderExists = await pathExists(targetFolder);
 
-  // --force bypasses update confirmation prompts.
-  const shouldForce = options.force ?? false;
-
-  if (folderExists && !shouldForce && !autoConfirm) {
+  if (folderExists && !autoConfirm) {
     const update = await confirm({
       message: `${agent.folder} already exists. Update source control skills?`,
       initialValue: true,
@@ -404,9 +399,11 @@ export async function initCommand(options: InitOptions = {}): Promise<void> {
     // skip the network-backed skills CLI in that case to keep dev iteration
     // fast and offline-friendly.
     if (import.meta.dir.includes("node_modules")) {
+      const skillsToInstall = SCM_SKILLS_BY_TYPE[scmType];
+      const skillsLabel = skillsToInstall.join(", ");
       const skillsSpinner = spinner();
       skillsSpinner.start(
-        `Installing ${getScmPrefix(scmType)}* skills locally for ${agent.name}...`,
+        `Installing ${skillsLabel} locally for ${agent.name}...`,
       );
       const skillsResult = await installLocalScmSkills({
         scmType,
@@ -415,11 +412,11 @@ export async function initCommand(options: InitOptions = {}): Promise<void> {
       });
       if (skillsResult.success) {
         skillsSpinner.stop(
-          `Installed ${getScmPrefix(scmType)}* skills locally for ${agent.name}`,
+          `Installed ${skillsLabel} locally for ${agent.name}`,
         );
       } else {
         skillsSpinner.stop(
-          `Skipped local ${getScmPrefix(scmType)}* skills install (${skillsResult.details})`,
+          `Skipped local ${skillsLabel} install (${skillsResult.details})`,
         );
       }
     }

package/src/commands/cli/init/scm.ts

@@ -2,7 +2,11 @@ import { join } from "path";
 import { readdir } from "fs/promises";
 import { copyFile, pathExists, ensureDir } from "@/services/system/copy.ts";
 import { getOppositeScriptExtension } from "@/services/system/detect.ts";
-import type { AgentKey, SourceControlType } from "@/services/config/index.ts";
+import {
+  SCM_SKILLS_BY_TYPE,
+  type AgentKey,
+  type SourceControlType,
+} from "@/services/config/index.ts";
 
 export const SCM_PREFIX_BY_TYPE: Record<SourceControlType, "gh-" | "sl-"> = {
   github: "gh-",
@@ -127,14 +131,21 @@ export interface InstallLocalScmSkillsOptions {
 
 export interface InstallLocalScmSkillsResult {
   success: boolean;
+  /** The explicit skill names that were requested (e.g. `["gh-commit", "gh-create-pr"]`). */
+  skills: readonly string[];
   /** Non-empty when `success` is false. */
   details: string;
 }
 
 /**
- * Install the SCM skill variants (gh-* or sl-*) locally into the current
- * project via `npx skills add`. The `-g` flag is intentionally omitted so
- * the skills are installed per-project (in the given `cwd`).
+ * Install the SCM skill variants (e.g. `gh-commit`, `gh-create-pr` for
+ * GitHub) locally into the current project via `npx skills add`. The `-g`
+ * flag is intentionally omitted so the skills are installed per-project
+ * (in the given `cwd`).
+ *
+ * Each skill is passed explicitly with `--skill <name>` — the skills CLI
+ * does not support glob patterns like `gh-*`, which would either fail or
+ * fall back to installing the entire skill set.
  *
  * This is best-effort: callers should treat a failed result as a warning,
  * not as a fatal error.
@@ -144,13 +155,15 @@ export async function installLocalScmSkills(
 ): Promise<InstallLocalScmSkillsResult> {
   const { scmType, agentKey, cwd } = options;
 
+  const skills = SCM_SKILLS_BY_TYPE[scmType];
+
   const npxPath = Bun.which("npx");
   if (!npxPath) {
-    return { success: false, details: "npx not found on PATH" };
+    return { success: false, skills, details: "npx not found on PATH" };
   }
 
-  const pattern = `${getScmPrefix(scmType)}*`;
   const agentFlag = SKILLS_AGENT_BY_KEY[agentKey];
+  const skillFlags = skills.flatMap((skill) => ["--skill", skill]);
 
   try {
     const proc = Bun.spawn({
@@ -160,8 +173,7 @@ export async function installLocalScmSkills(
         "skills",
         "add",
         SKILLS_REPO,
-        "--skill",
-        pattern,
+        ...skillFlags,
         "-a",
         agentFlag,
         "-y",
@@ -177,13 +189,18 @@ export async function installLocalScmSkills(
       proc.exited,
     ]);
     if (exitCode === 0) {
-      return { success: true, details: "" };
+      return { success: true, skills, details: "" };
     }
     const details = stderr.trim().length > 0 ? stderr.trim() : stdout.trim();
-    return { success: false, details: details || `exit code ${exitCode}` };
+    return {
+      success: false,
+      skills,
+      details: details || `exit code ${exitCode}`,
+    };
   } catch (error) {
     return {
       success: false,
+      skills,
       details: error instanceof Error ? error.message : String(error),
     };
   }

package/src/sdk/components/connectors.test.ts

@@ -659,3 +659,48 @@ describe("buildMergeConnector", () => {
     expect(barLine[84]).toBe("┤");
   });
 });
+
+// ─── Integration tests: connectors with computeLayout-produced nodes ──────
+
+describe("integration with computeLayout", () => {
+  test("connector from orchestrator to reclassified orphan child", () => {
+    const { computeLayout } = require("./layout.ts");
+    const layout = computeLayout([
+      { name: "orchestrator", status: "running", parents: [], startedAt: null, endedAt: null },
+      { name: "orphan", status: "pending", parents: ["nonexistent"], startedAt: null, endedAt: null },
+    ]);
+    const orch = layout.map["orchestrator"];
+    expect(orch.children).toHaveLength(1);
+    const conn = buildConnector(orch, layout.rowH, mockTheme);
+    expect(conn).not.toBeNull();
+    expect(conn!.height).toBeGreaterThan(0);
+  });
+
+  test("connector from parent to reclassified merge-to-single-parent node", () => {
+    const { computeLayout } = require("./layout.ts");
+    const layout = computeLayout([
+      { name: "orchestrator", status: "running", parents: [], startedAt: null, endedAt: null },
+      { name: "A", status: "pending", parents: ["orchestrator"], startedAt: null, endedAt: null },
+      { name: "M", status: "pending", parents: ["A", "nonexistent"], startedAt: null, endedAt: null },
+    ]);
+    const nodeA = layout.map["A"];
+    expect(nodeA.children).toHaveLength(1);
+    expect(nodeA.children[0].name).toBe("M");
+    const conn = buildConnector(nodeA, layout.rowH, mockTheme);
+    expect(conn).not.toBeNull();
+  });
+
+  test("merge connector still works for valid merge nodes", () => {
+    const { computeLayout } = require("./layout.ts");
+    const layout = computeLayout([
+      { name: "A", status: "pending", parents: [], startedAt: null, endedAt: null },
+      { name: "B", status: "pending", parents: [], startedAt: null, endedAt: null },
+      { name: "M", status: "pending", parents: ["A", "B"], startedAt: null, endedAt: null },
+    ]);
+    const nodeM = layout.map["M"];
+    expect(nodeM.parents).toEqual(["A", "B"]);
+    const mergeConn = buildMergeConnector(nodeM, layout.rowH, layout.map, mockTheme);
+    expect(mergeConn).not.toBeNull();
+    expect(mergeConn!.height).toBeGreaterThan(0);
+  });
+});

package/src/sdk/components/layout.test.ts

@@ -921,4 +921,325 @@ describe("computeLayout", () => {
       });
     }
   });
+
+  // ─── Edge cases: parent normalization ─────────
+
+  describe("missing parent fallback", () => {
+    test("session with missing parent falls back to orchestrator child", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("orphan", ["nonexistent"]),
+      ]);
+      // orphan should be a child of orchestrator, not a root
+      expect(r.roots).toHaveLength(1);
+      expect(r.roots[0]!.name).toBe("orchestrator");
+      expect(r.map["orchestrator"]!.children).toHaveLength(1);
+      expect(r.map["orchestrator"]!.children[0]!.name).toBe("orphan");
+      expect(r.map["orphan"]!.depth).toBe(1);
+    });
+
+    test("session with missing parent and no orchestrator becomes root", () => {
+      const r = computeLayout([
+        session("A"),
+        session("orphan", ["nonexistent"]),
+      ]);
+      // Without orchestrator, orphan becomes a root alongside A
+      expect(r.roots).toHaveLength(2);
+      expect(r.roots.map((n) => n.name)).toContain("orphan");
+    });
+
+    test("preserves raw parents array on LayoutNode even when normalized", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("orphan", ["nonexistent"]),
+      ]);
+      // raw parents metadata should be unchanged
+      expect(r.map["orphan"]!.parents).toEqual(["nonexistent"]);
+    });
+
+    test("multiple orphans all fall back to orchestrator", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("a", ["ghost-1"]),
+        session("b", ["ghost-2"]),
+      ]);
+      expect(r.roots).toHaveLength(1);
+      expect(r.map["orchestrator"]!.children).toHaveLength(2);
+      expect(r.map["a"]!.depth).toBe(1);
+      expect(r.map["b"]!.depth).toBe(1);
+    });
+
+    test("valid parent takes priority over orchestrator fallback", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("step-1", ["orchestrator"]),
+        session("child", ["step-1"]),
+      ]);
+      // child should be under step-1, not orchestrator
+      expect(r.map["step-1"]!.children).toHaveLength(1);
+      expect(r.map["step-1"]!.children[0]!.name).toBe("child");
+      expect(r.map["child"]!.depth).toBe(2);
+    });
+
+    test("orchestrator itself does not get reparented to itself", () => {
+      const r = computeLayout([session("orchestrator")]);
+      expect(r.roots).toHaveLength(1);
+      expect(r.roots[0]!.name).toBe("orchestrator");
+      expect(r.map["orchestrator"]!.children).toHaveLength(0);
+    });
+  });
+
+  describe("merge node with missing parents", () => {
+    test("merge with one missing parent reclassified as single-parent child", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("A", ["orchestrator"]),
+        session("M", ["A", "nonexistent"]),
+      ]);
+      // M should become a single-parent child of A (not a merge node)
+      expect(r.map["A"]!.children).toHaveLength(1);
+      expect(r.map["A"]!.children[0]!.name).toBe("M");
+      expect(r.map["M"]!.depth).toBe(2);
+    });
+
+    test("merge with all missing parents falls back to orchestrator child", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("M", ["ghost-1", "ghost-2"]),
+      ]);
+      // All parents missing → falls back to orchestrator
+      expect(r.map["orchestrator"]!.children).toHaveLength(1);
+      expect(r.map["orchestrator"]!.children[0]!.name).toBe("M");
+      expect(r.map["M"]!.depth).toBe(1);
+    });
+
+    test("merge with duplicate parents after filtering is deduplicated", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("A", ["orchestrator"]),
+        session("M", ["A", "A"]),
+      ]);
+      // Duplicate "A" deduplicated → single parent → tree child of A
+      expect(r.map["A"]!.children).toHaveLength(1);
+      expect(r.map["A"]!.children[0]!.name).toBe("M");
+    });
+  });
+
+  describe("chained merge node ordering", () => {
+    test("merge nodes in reverse order get correct depths", () => {
+      // M2 depends on M1, but M2 appears first in the sessions array
+      const r = computeLayout([
+        session("A"),
+        session("B"),
+        session("C"),
+        session("M2", ["M1", "C"]),  // M2 before M1 in array
+        session("M1", ["A", "B"]),
+      ]);
+      expect(r.map["M1"]!.depth).toBe(1);
+      expect(r.map["M2"]!.depth).toBe(2); // must be deeper than M1
+    });
+
+    test("indirect merge dependency: A,B → M1 → X; C,X → M2", () => {
+      const r = computeLayout([
+        session("A"),
+        session("B"),
+        session("C"),
+        session("M1", ["A", "B"]),
+        session("X", ["M1"]),
+        session("M2", ["C", "X"]),
+      ]);
+      expect(r.map["M1"]!.depth).toBe(1);
+      expect(r.map["X"]!.depth).toBe(2);
+      expect(r.map["M2"]!.depth).toBe(3);
+    });
+
+    test("indirect merge dependency in forward session order", () => {
+      const r = computeLayout([
+        session("A"),
+        session("B"),
+        session("C"),
+        session("M1", ["A", "B"]),
+        session("X", ["M1"]),
+        session("M2", ["C", "X"]),
+      ]);
+      expect(r.map["M1"]!.depth).toBe(1);
+      expect(r.map["X"]!.depth).toBe(2);
+      expect(r.map["M2"]!.depth).toBe(3);
+    });
+  });
+
+  describe("deeply nested tree", () => {
+    test("four levels of nesting with orchestrator", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("step-1", ["orchestrator"]),
+        session("step-2", ["step-1"]),
+        session("step-3", ["step-2"]),
+        session("step-4", ["step-3"]),
+      ]);
+      expect(r.map["orchestrator"]!.depth).toBe(0);
+      expect(r.map["step-1"]!.depth).toBe(1);
+      expect(r.map["step-2"]!.depth).toBe(2);
+      expect(r.map["step-3"]!.depth).toBe(3);
+      expect(r.map["step-4"]!.depth).toBe(4);
+      // All share x (single chain)
+      const x0 = r.map["orchestrator"]!.x;
+      for (const name of ["step-1", "step-2", "step-3", "step-4"]) {
+        expect(r.map[name]!.x).toBe(x0);
+      }
+    });
+  });
+
+  describe("merge node as single parent", () => {
+    test("child of merge node is placed correctly", () => {
+      const r = computeLayout([
+        session("A"),
+        session("B"),
+        session("M", ["A", "B"]),
+        session("child", ["M"]),
+      ]);
+      expect(r.map["M"]!.depth).toBe(1);
+      expect(r.map["child"]!.depth).toBe(2);
+      // child should be directly below M
+      expect(r.map["child"]!.x).toBe(r.map["M"]!.x);
+    });
+  });
+
+  describe("wide fan-out from non-root node", () => {
+    test("multiple children of a mid-tree node", () => {
+      const r = computeLayout([
+        session("orchestrator"),
+        session("parent", ["orchestrator"]),
+        session("c1", ["parent"]),
+        session("c2", ["parent"]),
+        session("c3", ["parent"]),
+      ]);
+      expect(r.map["parent"]!.depth).toBe(1);
+      expect(r.map["c1"]!.depth).toBe(2);
+      expect(r.map["c2"]!.depth).toBe(2);
+      expect(r.map["c3"]!.depth).toBe(2);
+      // parent centered over children
+      const parentX = r.map["parent"]!.x;
+      const c1X = r.map["c1"]!.x;
+      const c3X = r.map["c3"]!.x;
+      expect(parentX).toBe(Math.round((c1X + c3X) / 2));
+    });
+  });
+
+  // ─── Extended invariants for new topologies ───
+
+  describe("layout invariants (extended edge cases)", () => {
+    const EDGE_TOPOLOGIES = [
+      {
+        name: "missing parent → orchestrator fallback",
+        sessions: () => [
+          session("orchestrator"),
+          session("orphan", ["nonexistent"]),
+        ],
+      },
+      {
+        name: "merge with missing parent reclassified",
+        sessions: () => [
+          session("orchestrator"),
+          session("A", ["orchestrator"]),
+          session("M", ["A", "nonexistent"]),
+        ],
+      },
+      {
+        name: "chained merges in reverse order",
+        sessions: () => [
+          session("A"),
+          session("B"),
+          session("C"),
+          session("M2", ["M1", "C"]),
+          session("M1", ["A", "B"]),
+        ],
+      },
+      {
+        name: "indirect merge dependency",
+        sessions: () => [
+          session("A"),
+          session("B"),
+          session("C"),
+          session("M1", ["A", "B"]),
+          session("X", ["M1"]),
+          session("M2", ["C", "X"]),
+        ],
+      },
+      {
+        name: "deeply nested (5 levels)",
+        sessions: () => [
+          session("orchestrator"),
+          session("s1", ["orchestrator"]),
+          session("s2", ["s1"]),
+          session("s3", ["s2"]),
+          session("s4", ["s3"]),
+        ],
+      },
+      {
+        name: "wide fan-out from non-root",
+        sessions: () => [
+          session("orchestrator"),
+          session("parent", ["orchestrator"]),
+          session("c1", ["parent"]),
+          session("c2", ["parent"]),
+          session("c3", ["parent"]),
+        ],
+      },
+    ];
+
+    for (const topo of EDGE_TOPOLOGIES) {
+      test(`[${topo.name}] all x values are >= PAD`, () => {
+        const r = computeLayout(topo.sessions());
+        for (const node of Object.values(r.map)) {
+          expect(node.x).toBeGreaterThanOrEqual(PAD);
+        }
+      });
+
+      test(`[${topo.name}] all y values are >= PAD`, () => {
+        const r = computeLayout(topo.sessions());
+        for (const node of Object.values(r.map)) {
+          expect(node.y).toBeGreaterThanOrEqual(PAD);
+        }
+      });
+
+      test(`[${topo.name}] width = max(node.x + NODE_W) + PAD`, () => {
+        const r = computeLayout(topo.sessions());
+        const rightmost = Math.max(...Object.values(r.map).map((n) => n.x + NODE_W));
+        expect(r.width).toBe(rightmost + PAD);
+      });
+
+      test(`[${topo.name}] height = max(node.y + NODE_H) + PAD`, () => {
+        const r = computeLayout(topo.sessions());
+        const bottommost = Math.max(...Object.values(r.map).map((n) => n.y + NODE_H));
+        expect(r.height).toBe(bottommost + PAD);
+      });
+
+      test(`[${topo.name}] nodes at same depth share the same y`, () => {
+        const r = computeLayout(topo.sessions());
+        const byDepth: Record<number, number[]> = {};
+        for (const node of Object.values(r.map)) {
+          (byDepth[node.depth] ??= []).push(node.y);
+        }
+        for (const ys of Object.values(byDepth)) {
+          const first = ys[0]!;
+          for (const y of ys) expect(y).toBe(first);
+        }
+      });
+
+      test(`[${topo.name}] no horizontal overlap between nodes at same depth`, () => {
+        const r = computeLayout(topo.sessions());
+        const byDepth: Record<number, number[]> = {};
+        for (const node of Object.values(r.map)) {
+          (byDepth[node.depth] ??= []).push(node.x);
+        }
+        for (const xs of Object.values(byDepth)) {
+          xs.sort((a, b) => a - b);
+          for (let i = 1; i < xs.length; i++) {
+            expect(xs[i]! - xs[i - 1]!).toBeGreaterThanOrEqual(NODE_W + H_GAP);
+          }
+        }
+      });
+    }
+  });
 });